【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（一）-初步認識SD卡
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（二）-了解SD總線，命令的相關介紹
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（三）-SD卡的操作流程
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（四）-介紹庫函數，獲取一些SD卡的信息
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（五）-文件管理初步介紹
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（六）-FatFs使用的思路介紹
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（七）-准備移植FatFs
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（八）-認識內存管理
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（終）-配合內存管理來遍歷SD卡
FatFs官方網站：http://elm-chan.org/fsw/ff/00index_e.html
注意一點，在使用文件管理之前，你應該要保證和你連接的設備，所有你用到的功能都是調通了的
例如
1.你的設備是SD卡，或是Flash之類的
2.功能實現的部分，例如一些《初始化》、《讀功能》，或是《寫功能》
這些東西都實現了，才來添加FatFs文件管理
因為在《diskio.c》里，需要執行你已經封裝好的函數，也就是上兩行說的《初始化》《讀功能》《寫功能》之類的
如果還沒調通，就來移植，只怕問題會更多
那如果一切都准備好了，下面就來移植FatFs吧
在我的范例教程里，用的是《ff11a》
我知道目前（2020.12.14）最新版本是《ff14a》，並且和《ff11a》有些出入
但只要懂《ff11a》的思路，往后的版本也能駕輕就熟
《2021.02.02修改：我改用10b版本了，正點和野火也是用這個版本，我是用11a后發現有問題，才改的，我不知道在哪看的，以為他們都是用11a版本》
《但是添加過程都差不多，下面的文字和圖片有出入，我就懶得改了。。。抱歉》
在官網的歷史版本里面可以下載【Download：Previous Releases】，找到R0.11a下載 找到R0.10b下載
此壓縮檔里面有兩個文件
等等在開Keil，先去自己的項目路徑下，新建一個FatFs文件夾（文件分類后，比較方便閱讀）
把壓縮檔里面的src復制到剛建的FatFs文件夾
doc就不用復制了
此時，打開Keil，在project下，新建一個FATFS文件夾，並且添加2個源文件《diskio.c》《ff.c》
再把頭文件路徑也填上，編譯后，讓頭文件顯示出來，有錯誤沒關系，因為我們之后就會修改
首先來看《ffconf.h》，通過這些宏定義，可以設定你不需要什么功能，畢竟這樣可以節省空間
另外還可以設置編碼（_CODE_PAGE），中文編碼的文件略大一些，如果要用中文編碼，還需要去option文件夾，找到cc936源文件，添加到自己項目，這里我先設置為1
還有是否要支持長文件名，是否支持格式化...等等
/*---------------------------------------------------------------------------/ / FatFs - FAT file system module configuration file R0.11a (C)ChaN, 2015 /---------------------------------------------------------------------------*/ #define _FFCONF 64180 /* Revision ID */ /*---------------------------------------------------------------------------/ / Function Configurations /---------------------------------------------------------------------------*/ #define _FS_READONLY 0 // 是否只讀 /* This option switches read-only configuration. (0:Read/Write or 1:Read-only) / Read-only configuration removes writing API functions, f_write(), f_sync(), / f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree() / and optional writing functions as well. */ #define _FS_MINIMIZE 0 // 是否使用裁剪文件 /* This option defines minimization level to remove some basic API functions. / / 0: All basic functions are enabled. / 1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_chmod(), f_utime(), / f_truncate() and f_rename() function are removed. / 2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1. / 3: f_lseek() function is removed in addition to 2. */ #define _USE_STRFUNC 0 // 是否允許字符串操作 /* This option switches string functions, f_gets(), f_putc(), f_puts() and / f_printf(). / / 0: Disable string functions. / 1: Enable without LF-CRLF conversion. / 2: Enable with LF-CRLF conversion. */ #define _USE_FIND 0 // 切換過濾目錄讀取功能和相關功能 /* This option switches filtered directory read feature and related functions, / f_findfirst() and f_findnext(). (0:Disable or 1:Enable) */ #define _USE_MKFS 0 // 是否開啟格式化功能 /* This option switches f_mkfs() function. (0:Disable or 1:Enable) */ #define _USE_FASTSEEK 0 // 是否開啟快速索引 /* This option switches fast seek feature. (0:Disable or 1:Enable) */ #define _USE_LABEL 0 // 是否開啟切換卷標功能 /* This option switches volume label functions, f_getlabel() and f_setlabel(). / (0:Disable or 1:Enable) */ #define _USE_FORWARD 0 // 是否允許f_forward函數 /* This option switches f_forward() function. (0:Disable or 1:Enable) / To enable it, also _FS_TINY need to be set to 1. */ /*---------------------------------------------------------------------------/ / Locale and Namespace Configurations /---------------------------------------------------------------------------*/ // 編碼【932為日文】【936為簡體中文】【949為韓文】【950為繁體中文】 #define _CODE_PAGE 1 /* This option specifies the OEM code page to be used on the target system. / Incorrect setting of the code page can cause a file open failure. / / 1 - ASCII (No extended character. Non-LFN cfg. only) / 437 - U.S. / 720 - Arabic / 737 - Greek / 771 - KBL / 775 - Baltic / 850 - Latin 1 / 852 - Latin 2 / 855 - Cyrillic / 857 - Turkish / 860 - Portuguese / 861 - Icelandic / 862 - Hebrew / 863 - Canadian French / 864 - Arabic / 865 - Nordic / 866 - Russian / 869 - Greek 2 / 932 - Japanese (DBCS) / 936 - Simplified Chinese (DBCS) / 949 - Korean (DBCS) / 950 - Traditional Chinese (DBCS) */ #define _USE_LFN 0 // 是否支持長文件名 #define _MAX_LFN 255 /* The _USE_LFN option switches the LFN feature. / / 0: Disable LFN feature. _MAX_LFN has no effect. / 1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe. / 2: Enable LFN with dynamic working buffer on the STACK. / 3: Enable LFN with dynamic working buffer on the HEAP. / / When enable the LFN feature, Unicode handling functions (option/unicode.c) must / be added to the project. The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes. / When use stack for the working buffer, take care on stack overflow. When use heap / memory for the working buffer, memory management functions, ff_memalloc() and / ff_memfree(), must be added to the project. */ #define _LFN_UNICODE 0 // 切換字符編碼 /* This option switches character encoding on the API. (0:ANSI/OEM or 1:Unicode) / To use Unicode string for the path name, enable LFN feature and set _LFN_UNICODE / to 1. This option also affects behavior of string I/O functions. */ #define _STRF_ENCODE 3 // 編碼相關 /* When _LFN_UNICODE is 1, this option selects the character encoding on the file to / be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf(). / / 0: ANSI/OEM / 1: UTF-16LE / 2: UTF-16BE / 3: UTF-8 / / When _LFN_UNICODE is 0, this option has no effect. */ #define _FS_RPATH 0 // 是否允許相對路徑 /* This option configures relative path feature. / / 0: Disable relative path feature and remove related functions. / 1: Enable relative path feature. f_chdir() and f_chdrive() are available. / 2: f_getcwd() function is available in addition to 1. / / Note that directory items read via f_readdir() are affected by this option. */ /*---------------------------------------------------------------------------/ / Drive/Volume Configurations /---------------------------------------------------------------------------*/ #define _VOLUMES 1 // 磁盤邏輯卷數 /* Number of volumes (logical drives) to be used. */ #define _STR_VOLUME_ID 0 #define _VOLUME_STRS "RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3" /* _STR_VOLUME_ID option switches string volume ID feature. / When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive / number in the path name. _VOLUME_STRS defines the drive ID strings for each / logical drives. Number of items must be equal to _VOLUMES. Valid characters for / the drive ID strings are: A-Z and 0-9. */ #define _MULTI_PARTITION 0 // 分區選項，默認為0，即一個分區，若想要多分區可自行設置 /* This option switches multi-partition feature. By default (0), each logical drive / number is bound to the same physical drive number and only an FAT volume found on / the physical drive will be mounted. When multi-partition feature is enabled (1), / each logical drive number is bound to arbitrary physical drive and partition / listed in the VolToPart[]. Also f_fdisk() funciton will be available. */ #define _MIN_SS 512 // 扇區緩沖最小值 #define _MAX_SS 512 // 扇區緩沖最大值 /* These options configure the range of sector size to be supported. (512, 1024, / 2048 or 4096) Always set both 512 for most systems, all type of memory cards and / harddisk. But a larger value may be required for on-board flash memory and some / type of optical media. When _MAX_SS is larger than _MIN_SS, FatFs is configured / to variable sector size and GET_SECTOR_SIZE command must be implemented to the / disk_ioctl() function. */ #define _USE_TRIM 0 /* This option switches ATA-TRIM feature. (0:Disable or 1:Enable) / To enable Trim feature, also CTRL_TRIM command should be implemented to the / disk_ioctl() function. */ #define _FS_NOFSINFO 0 /* If you need to know correct free space on the FAT32 volume, set bit 0 of this / option, and f_getfree() function at first time after volume mount will force / a full FAT scan. Bit 1 controls the use of last allocated cluster number. / / bit0=0: Use free cluster count in the FSINFO if available. / bit0=1: Do not trust free cluster count in the FSINFO. / bit1=0: Use last allocated cluster number in the FSINFO if available. / bit1=1: Do not trust last allocated cluster number in the FSINFO. */ /*---------------------------------------------------------------------------/ / System Configurations /---------------------------------------------------------------------------*/ #define _FS_TINY 0 // 文件系統為標准的還是微型的 /* This option switches tiny buffer configuration. (0:Normal or 1:Tiny) / At the tiny configuration, size of the file object (FIL) is reduced _MAX_SS / bytes. Instead of private sector buffer eliminated from the file object, / common sector buffer in the file system object (FATFS) is used for the file / data transfer. */ #define _FS_NORTC 0 #define _NORTC_MON 1 #define _NORTC_MDAY 1 #define _NORTC_YEAR 2015 /* The _FS_NORTC option switches timestamp feature. If the system does not have / an RTC function or valid timestamp is not needed, set _FS_NORTC to 1 to disable / the timestamp feature. All objects modified by FatFs will have a fixed timestamp / defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR. / When timestamp feature is enabled (_FS_NORTC == 0), get_fattime() function need / to be added to the project to read current time form RTC. _NORTC_MON, / _NORTC_MDAY and _NORTC_YEAR have no effect. / These options have no effect at read-only configuration (_FS_READONLY == 1). */ #define _FS_LOCK 0 /* The _FS_LOCK option switches file lock feature to control duplicated file open / and illegal operation to open objects. This option must be 0 when _FS_READONLY / is 1. / / 0: Disable file lock feature. To avoid volume corruption, application program / should avoid illegal open, remove and rename to the open objects. / >0: Enable file lock feature. The value defines how many files/sub-directories / can be opened simultaneously under file lock control. Note that the file / lock feature is independent of re-entrancy. */ #define _FS_REENTRANT 0 #define _FS_TIMEOUT 1000 #define _SYNC_t HANDLE /* The _FS_REENTRANT option switches the re-entrancy (thread safe) of the FatFs / module itself. Note that regardless of this option, file access to different / volume is always re-entrant and volume control functions, f_mount(), f_mkfs() / and f_fdisk() function, are always not re-entrant. Only file/directory access / to the same volume is under control of this feature. / / 0: Disable re-entrancy. _FS_TIMEOUT and _SYNC_t have no effect. / 1: Enable re-entrancy. Also user provided synchronization handlers, / ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj() / function, must be added to the project. Samples are available in / option/syscall.c. / / The _FS_TIMEOUT defines timeout period in unit of time tick. / The _SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*, / SemaphoreHandle_t and etc.. A header file for O/S definitions needs to be / included somewhere in the scope of ff.c. */ #define _WORD_ACCESS 0 // 數據遞進格式 /* The _WORD_ACCESS option is an only platform dependent option. It defines / which access method is used to the word data on the FAT volume. / / 0: Byte-by-byte access. Always compatible with all platforms. / 1: Word access. Do not choose this unless under both the following conditions. / / * Address misaligned memory access is always allowed to ALL instructions. / * Byte order on the memory is little-endian. / / If it is the case, _WORD_ACCESS can also be set to 1 to reduce code size. / Following table shows allowable settings of some type of processors. / / ARM7TDMI 0 *2 ColdFire 0 *1 V850E 0 *2 / Cortex-M3 0 *3 Z80 0/1 V850ES 0/1 / Cortex-M0 0 *2 x86 0/1 TLCS-870 0/1 / AVR 0/1 RX600(LE) 0/1 TLCS-900 0/1 / AVR32 0 *1 RL78 0 *2 R32C 0 *2 / PIC18 0/1 SH-2 0 *1 M16C 0/1 / PIC24 0 *2 H8S 0 *1 MSP430 0 *2 / PIC32 0 *1 H8/300H 0 *1 8051 0/1 / / *1:Big-endian. / *2:Unaligned memory access is not supported. / *3:Some compilers generate LDM/STM for mem_cpy function. */
對應上面部分宏定義，我整理了一個表格，可以一目了然的認識宏定義是做什么事情
《2021.01.16修改：不用自己的表格了，官方有做出一個表格》
接着來看《diskio.c》編譯的錯誤基本都在這了
首先是把幾個頭文件注釋了，這幾個頭文件是其他范例有的，我們這里要用自己的頭文件
下面的三個宏定義《ATA》《MMC》《USB》，可以改成自己想要的名稱，例如我的板子上有SD、Flash，干脆就定0和1
#include "sdio_sdcard.h" #define SD 0 #define FLASH 1
然后把函數《disk_status》《disk_initialize》《disk_read》《disk_write》里面執行的代碼注釋了，或者刪除也可以，未來要添加自己的代碼（這里先不添加，先找出所有錯誤）
對了，由於我上面改了宏定義，這里switch-case也要做一些修改（圖片原來的ATA、MMC、USB，要修改成SD和FLASH）
DSTATUS disk_status (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
int result;
switch (pdrv) {
case SD :
return stat;
case FLASH :
return stat;
}
return STA_NOINIT;
}
再次編譯，發現錯誤
解決這個錯誤有兩個方法，但是這兩個方法，要用哪個，需要取決於你應用的設計
get_fattime是獲取當前時間
如果不需要，在《ffconf.h》里面，找到宏定義《#define _FS_NORTC》，改為1，即可關閉
如果需要這個功能，需要在《diskio.c》里面，實現get_fattime函數，代碼如下
DWORD get_fattime(void) {
/* 返回當前時間戳 */
return ((DWORD)(2015 - 1980) << 25) /* Year 2015 */
| ((DWORD)1 << 21) /* Month 1 */
| ((DWORD)1 << 16) /* Mday 1 */
| ((DWORD)0 << 11) /* Hour 0 */
| ((DWORD)0 << 5) /* Min 0 */
| ((DWORD)0 >> 1); /* Sec 0 */
}
我不需要這個功能，我直接設定宏定義為1，然后編譯，這時錯誤就沒有了
下面先完成 《diskio.c》代碼的添加
源文件《sdio_sdcard.c》和頭文件《sdio_sdcard.h》，我會放在文章的最后
里面包含SD_Init函數
另外，這函數又是在做什么事情的？我兩篇博客分別提到思路以及實現
我的第三篇博客【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（三）-SD卡的操作流程，里面有提到圖形化流程，也是SD_Init需要做的事情
我的第四篇博客【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（四）-介紹庫函數，獲取一些SD卡的信息，這篇才是真正講到如何使用庫函數，完成SD_Init初始化
但有一點需要注意！我里面提到的9個步驟（第10步驟不是初始化該做的事），我是拆分開來，一部分一部分代碼來講解的，而本篇文章末了的代碼，是整合過的，就這一點不同而已
SD_Error SD_Init(void)
{
...
...
}
FatFs文件管理的宗旨，你不要自己去調用SD的初始化
由文件管理自己去調用，但你還是要給出命令的，例如接口《f_mount》
SD_Init會返回一個狀態SD_Error，這個狀態會通知文件管理系統，然后《f_mount》也有一個返回值，最終我們就會得知初始化的結果
DSTATUS disk_initialize (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
int result = 0;
switch (pdrv) {
case SD :
result = SD_Init(); // SD卡初始化
break;
case W25Qxx :
break;
}
if(result)return STA_NOINIT;
else return 0; //初始化成功
}
完成了設備接口的配置，我們回到自己的應用層，嘗試執行《f_mount》，參數2：path，這里給的邏輯編號，是你在《diskio.c》里面的宏定義，SD我定義為0，這里就給 "0："
最終函數會返回一個狀態《FRESULT》，如果返回是0，代表正常
《2021.01.14新增的內容：f_mount就是掛起，掛起后你才可以使用一些功能，例如讀取f_open，或是打開文件夾f_opendir，寫入數據f_write。。。等等》
#include "stm32f4xx.h"
#include "delay.h"
// 外設
#include "sdio_sdcard.h"
#include "usart.h"
// FatFS
#include "diskio.h"
#include "ff.h"
FATFS *fs[_VOLUMES]; // FatFs文件系統對象
FRESULT res_sd; // 文件操作結果
int main(void)
{
delay_init(180);
/* 串口初始化 */
uart1_init(9600);
/* 文件管理系統初始化 */
res_sd = f_mount(fs[0],"0:",1);
USART_SendData(USART1, res_sd); // 打印處理結果
while(1);
}
執行效果如下，記得要用HEX顯示
/* File function return code (FRESULT) */
typedef enum {
FR_OK = 0, /* (0) Succeeded */
FR_DISK_ERR, /* (1) A hard error occurred in the low level disk I/O layer */
FR_INT_ERR, /* (2) Assertion failed */
FR_NOT_READY, /* (3) The physical drive cannot work */
FR_NO_FILE, /* (4) Could not find the file */
FR_NO_PATH, /* (5) Could not find the path */
FR_INVALID_NAME, /* (6) The path name format is invalid */
FR_DENIED, /* (7) Access denied due to prohibited access or directory full */
FR_EXIST, /* (8) Access denied due to prohibited access */
FR_INVALID_OBJECT, /* (9) The file/directory object is invalid */
FR_WRITE_PROTECTED, /* (10) The physical drive is write protected */
FR_INVALID_DRIVE, /* (11) The logical drive number is invalid */
FR_NOT_ENABLED, /* (12) The volume has no work area */
FR_NO_FILESYSTEM, /* (13) There is no valid FAT volume */
FR_MKFS_ABORTED, /* (14) The f_mkfs() aborted due to any parameter error */
FR_TIMEOUT, /* (15) Could not get a grant to access the volume within defined period */
FR_LOCKED, /* (16) The operation is rejected according to the file sharing policy */
FR_NOT_ENOUGH_CORE, /* (17) LFN working buffer could not be allocated */
FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > _FS_LOCK */
FR_INVALID_PARAMETER /* (19) Given parameter is invalid */
} FRESULT;
至此，移植FatFs初步算是成功了（因為執行f_mount返回的是00，代表成功）
下一篇，先來研究內存管理，因為FatFs文件管理需要使用到
等內存管理結束后，會回頭處理讀取SD卡的事情
《2021.01.14新增的內容：這里測試了路徑，我把測試結果貼上來，共兩張圖，以及代碼塊》
《第一張圖是我SD卡的內容，包含幾個文件夾，和幾張圖片，以及文件夾的嵌套關系》
《第二張圖就是測試結果了，我把結果都寫在注釋里面，當前代碼的行數，要對照上一行的注釋》
《代碼塊：因為涉及到讀取，所以必須修改diskio.c》
DRESULT disk_read (
BYTE pdrv, /* Physical drive nmuber (0..) */
BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Sector address (LBA) */
UINT count /* Number of sectors to read (1..128) */
)
{
u8 res=0;
if (!count)return RES_PARERR;//count不能等於0，否則返回參數錯誤
switch(pdrv)
{
case SD://SD卡
res=SD_ReadDisk(buff,sector,count);
while(res)//讀出錯
{
SD_Init(); //重新初始化SD卡
res=SD_ReadDisk(buff,sector,count);
//printf("sd rd error:%d\r\n",res);
}
break;
case W25Qxx://外部flash
break;
default:
res=1;
}
//處理返回值，將SPI_SD_driver.c的返回值轉成ff.c的返回值
if(res==0x00)return RES_OK;
else return RES_ERROR;
}
最后，這是《sdio_sdcard.c》代碼的全部（代碼略長，這里建議用ctrl+F，例如搜尋SD_Init）
#include "sdio_sdcard.h"
#include "string.h"
#include "sys.h"
#include "usart.h"
/*用於sdio初始化的結構體*/
SDIO_InitTypeDef SDIO_InitStructure;
SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
SDIO_DataInitTypeDef SDIO_DataInitStructure;
SD_Error CmdError(void);
SD_Error CmdResp7Error(void);
SD_Error CmdResp1Error(u8 cmd);
SD_Error CmdResp3Error(void);
SD_Error CmdResp2Error(void);
SD_Error CmdResp6Error(u8 cmd,u16*prca);
SD_Error SDEnWideBus(u8 enx);
SD_Error IsCardProgramming(u8 *pstatus);
SD_Error FindSCR(u16 rca,u32 *pscr);
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes);
static u8 CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1; //SD卡類型（默認為1.x卡）
static u32 CSD_Tab[4],CID_Tab[4],RCA=0; //SD卡CSD,CID以及相對地址(RCA)數據
static u8 DeviceMode=SD_DMA_MODE; //工作模式,注意,工作模式必須通過SD_SetDeviceMode,后才算數.這里只是定義一個默認的模式(SD_DMA_MODE)
static u8 StopCondition=0; //是否發送停止傳輸標志位,DMA多塊讀寫的時候用到
volatile SD_Error TransferError=SD_OK; //數據傳輸錯誤標志,DMA讀寫時使用
volatile u8 TransferEnd=0; //傳輸結束標志,DMA讀寫時使用
SD_CardInfo SDCardInfo; //SD卡信息
//SD_ReadDisk/SD_WriteDisk函數專用buf,當這兩個函數的數據緩存區地址不是4字節對齊的時候,
//需要用到該數組,確保數據緩存區地址是4字節對齊的.
__align(4) u8 SDIO_DATA_BUFFER[512];
void SDIO_Register_Deinit()
{
SDIO->POWER=0x00000000;
SDIO->CLKCR=0x00000000;
SDIO->ARG=0x00000000;
SDIO->CMD=0x00000000;
SDIO->DTIMER=0x00000000;
SDIO->DLEN=0x00000000;
SDIO->DCTRL=0x00000000;
SDIO->ICR=0x00C007FF;
SDIO->MASK=0x00000000;
}
//初始化SD卡
//返回值:錯誤代碼;(0,無錯誤)
SD_Error SD_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
SD_Error errorstatus=SD_OK;
u8 clkdiv=0;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOD|RCC_AHB1Periph_DMA2, ENABLE);//使能GPIOC,GPIOD DMA2時鍾
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO時鍾使能
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO復位
GPIO_InitStructure.GPIO_Pin =GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12; //PC8,9,10,11,12復用功能輸出
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//復用功能
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//100M
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
GPIO_Init(GPIOC, &GPIO_InitStructure);// PC8,9,10,11,12復用功能輸出
GPIO_InitStructure.GPIO_Pin =GPIO_Pin_2;
GPIO_Init(GPIOD, &GPIO_InitStructure);//PD2復用功能輸出
//引腳復用映射設置
GPIO_PinAFConfig(GPIOC,GPIO_PinSource8,GPIO_AF_SDIO); //PC8,AF12
GPIO_PinAFConfig(GPIOC,GPIO_PinSource9,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOD,GPIO_PinSource2,GPIO_AF_SDIO);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, DISABLE);//SDIO結束復位
//SDIO外設寄存器設置為默認值
SDIO_Register_Deinit();
NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//搶占優先級3
NVIC_InitStructure.NVIC_IRQChannelSubPriority =0; //子優先級3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根據指定的參數初始化VIC寄存器
errorstatus=SD_PowerON(); //SD卡上電，設置頻率不超過400KHz，做一系列的判斷，檢測卡的類型等等，最后返回響應結果。現階段最后有可能的命令是CMD41（SD卡）或是CND1（MMC卡）
if(errorstatus==SD_OK)errorstatus=SD_InitializeCards(); //初始化SD卡（發送CMD2、CMD3、CMD9，CMD9之后，進入數據傳輸模式）
if(errorstatus==SD_OK)errorstatus=SD_GetCardInfo(&SDCardInfo); //獲取卡信息（解析SD卡，例如容量）
if(errorstatus==SD_OK)errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//選中SD卡
if(errorstatus==SD_OK)errorstatus=SD_EnableWideBusOperation(SDIO_BusWide_4b); //設置4位數據寬度,MMC卡則需用8位
if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType)) {
// 判斷SD卡版本，來設置卡的時鍾
if(SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1||SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)
{
clkdiv=SDIO_TRANSFER_CLK_DIV+2; //V1.1/V2.0卡，設置最高48/4=12Mhz
}
else clkdiv=SDIO_TRANSFER_CLK_DIV; //SDHC等其他卡，設置最高48/2=24Mhz
SDIO_Clock_Set(clkdiv); //設置時鍾頻率,SDIO時鍾計算公式:SDIO_CK時鍾=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定為48Mhz
//errorstatus=SD_SetDeviceMode(SD_DMA_MODE); //設置為DMA模式
errorstatus=SD_SetDeviceMode(SD_POLLING_MODE);//設置為查詢模式
}
return errorstatus;
}
//SDIO時鍾初始化設置
//clkdiv:時鍾分頻系數
//CK時鍾=SDIOCLK/[clkdiv+2];(SDIOCLK時鍾固定為48Mhz)
void SDIO_Clock_Set(u8 clkdiv)
{
u32 tmpreg=SDIO->CLKCR;
tmpreg&=0XFFFFFF00;
tmpreg|=clkdiv;
SDIO->CLKCR=tmpreg;
}
//卡上電
//查詢所有SDIO接口上的卡設備,並查詢其電壓和配置時鍾
//返回值:錯誤代碼;(0,無錯誤)
SD_Error SD_PowerON(void)
{
u8 i=0;
SD_Error errorstatus=SD_OK;
u32 response=0,count=0,validvoltage=0;
u32 SDType=SD_STD_CAPACITY;
/*初始化時的時鍾不能大於400KHz*/
SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV; /* HCLK = 72MHz, SDIOCLK = 72MHz, SDIO_CK = HCLK/(178 + 2) = 400 KHz */
SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable; //不使用bypass模式，直接用HCLK進行分頻得到SDIO_CK
SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable; // 空閑時不關閉時鍾電源
SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b; //1位數據線
SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;//硬件流
SDIO_Init(&SDIO_InitStructure);
SDIO_SetPowerState(SDIO_PowerState_ON); //上電狀態,開啟卡時鍾
SDIO->CLKCR|=1<<8; //SDIOCK使能
/* --------------------------------- 執行CMD0 ------------------------------------ */
for(i=0;i<74;i++)
{
SDIO_CmdInitStructure.SDIO_Argument = 0x0;//發送CMD0進入IDLE STAGE模式命令.
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE; //cmd0
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No; //無響應
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable; //則CPSM在開始發送命令之前等待數據傳輸結束。
SDIO_SendCommand(&SDIO_CmdInitStructure); //寫命令進命令寄存器
errorstatus=CmdError();
if(errorstatus==SD_OK)break;
}
if(errorstatus)return errorstatus;//返回錯誤狀態
/* --------------------------------- 執行CMD8 ------------------------------------ */
SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN; //發送CMD8,短響應,檢查SD卡接口特性
SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND; //cmd8
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r7
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No; //關閉等待中斷
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp7Error(); //等待R7響應
/* --------------------------------- 執行CMD55 ------------------------------------ */
if(errorstatus==SD_OK) //R7響應正常
{
CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0; //SD 2.0卡
SDType=SD_HIGH_CAPACITY; //高容量卡
}
SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發送CMD55,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); //發送CMD55,短響應
errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應
if(errorstatus==SD_OK)//SD2.0/SD 1.1,否則為MMC卡
{
//SD卡,發送ACMD41 SD_APP_OP_COND,參數為:0x80100000
while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
{
// 這里有個疑問，上面已經發送過CMD55了，為什么這里還要再發一次，我知道CMD55是復合指令，發送CMD41之前需要發送的
// 但下面又再發送一次，正點原子完全不解釋，非常順其自然的帶過，野火也懷疑了一下，但是也不清楚為什么這么做
SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發送CMD55,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD; //CMD55
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); //發送CMD55,短響應
errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
//acmd41，命令參數由支持的電壓范圍及HCS位組成，HCS位置一來區分卡是SDSc還是sdhc
SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType; //發送ACMD41,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r3
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp3Error(); //等待R3響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
response=SDIO->RESP1;; //得到響應
validvoltage=(((response>>31)==1)?1:0); //判斷SD卡上電是否完成
count++;
}
if(count>=SD_MAX_VOLT_TRIAL)
{
errorstatus=SD_INVALID_VOLTRANGE;
return errorstatus;
}
if(response&=SD_HIGH_CAPACITY)
{
CardType=SDIO_HIGH_CAPACITY_SD_CARD;
}
}
else//MMC卡
{
//MMC卡,發送CMD1 SDIO_SEND_OP_COND,參數為:0x80FF8000
while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
{
SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_MMC;//發送CMD1,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_OP_COND;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r3
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp3Error(); //等待R3響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
response=SDIO->RESP1;; //得到響應
validvoltage=(((response>>31)==1)?1:0);
count++;
}
if(count>=SD_MAX_VOLT_TRIAL)
{
errorstatus=SD_INVALID_VOLTRANGE;
return errorstatus;
}
CardType=SDIO_MULTIMEDIA_CARD;
}
return(errorstatus);
}
//SD卡 Power OFF
//返回值:錯誤代碼;(0,無錯誤)
SD_Error SD_PowerOFF(void)
{
SDIO_SetPowerState(SDIO_PowerState_OFF);//SDIO電源關閉,時鍾停止
return SD_OK;
}
//初始化所有的卡,並讓卡進入就緒狀態
//返回值:錯誤代碼
SD_Error SD_InitializeCards(void)
{
SD_Error errorstatus=SD_OK;
u16 rca = 0x01;
if (SDIO_GetPowerState() == SDIO_PowerState_OFF) //檢查電源狀態,確保為上電狀態
{
errorstatus = SD_REQUEST_NOT_APPLICABLE;
return(errorstatus);
}
if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD
{
SDIO_CmdInitStructure.SDIO_Argument = 0x0;//發送CMD2,取得CID,長響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ALL_SEND_CID;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);//發送CMD2,取得CID,長響應
errorstatus=CmdResp2Error(); //等待R2響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
CID_Tab[0]=SDIO->RESP1;
CID_Tab[1]=SDIO->RESP2;
CID_Tab[2]=SDIO->RESP3;
CID_Tab[3]=SDIO->RESP4;
}
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_SECURE_DIGITAL_IO_COMBO_CARD==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))//判斷卡類型
{
SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發送CMD3,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); //發送CMD3,短響應
errorstatus=CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}
if (SDIO_MULTIMEDIA_CARD==CardType)
{
SDIO_CmdInitStructure.SDIO_Argument = (u32)(rca<<16);//發送CMD3,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); //發送CMD3,短響應
errorstatus=CmdResp2Error(); //等待R2響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}
if (SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD
{
RCA = rca;
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);//發送CMD9+卡RCA,取得CSD,長響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_CSD;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp2Error(); //等待R2響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
CSD_Tab[0]=SDIO->RESP1;
CSD_Tab[1]=SDIO->RESP2;
CSD_Tab[2]=SDIO->RESP3;
CSD_Tab[3]=SDIO->RESP4;
}
return SD_OK;//卡初始化成功
}
//得到卡信息
//cardinfo:卡信息存儲區
//返回值:錯誤狀態
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
{
SD_Error errorstatus=SD_OK;
u8 tmp=0;
cardinfo->CardType=(u8)CardType; //卡類型
cardinfo->RCA=(u16)RCA; //卡RCA值
tmp=(u8)((CSD_Tab[0]&0xFF000000)>>24);
cardinfo->SD_csd.CSDStruct=(tmp&0xC0)>>6; //CSD結構
cardinfo->SD_csd.SysSpecVersion=(tmp&0x3C)>>2; //2.0協議還沒定義這部分(為保留),應該是后續協議定義的
cardinfo->SD_csd.Reserved1=tmp&0x03; //2個保留位
tmp=(u8)((CSD_Tab[0]&0x00FF0000)>>16); //第1個字節
cardinfo->SD_csd.TAAC=tmp; //數據讀時間1
tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8); //第2個字節
cardinfo->SD_csd.NSAC=tmp; //數據讀時間2
tmp=(u8)(CSD_Tab[0]&0x000000FF); //第3個字節
cardinfo->SD_csd.MaxBusClkFrec=tmp; //傳輸速度
tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24); //第4個字節
cardinfo->SD_csd.CardComdClasses=tmp<<4; //卡指令類高四位
tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16); //第5個字節
cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令類低四位
cardinfo->SD_csd.RdBlockLen=tmp&0x0F; //最大讀取數據長度
tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8); //第6個字節
cardinfo->SD_csd.PartBlockRead=(tmp&0x80)>>7; //允許分塊讀
cardinfo->SD_csd.WrBlockMisalign=(tmp&0x40)>>6; //寫塊錯位
cardinfo->SD_csd.RdBlockMisalign=(tmp&0x20)>>5; //讀塊錯位
cardinfo->SD_csd.DSRImpl=(tmp&0x10)>>4;
cardinfo->SD_csd.Reserved2=0; //保留
if((CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1)||(CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)||(SDIO_MULTIMEDIA_CARD==CardType))//標准1.1/2.0卡/MMC卡
{
cardinfo->SD_csd.DeviceSize=(tmp&0x03)<<10; //C_SIZE(12位)
tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7個字節
cardinfo->SD_csd.DeviceSize|=(tmp)<<2;
tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8個字節
cardinfo->SD_csd.DeviceSize|=(tmp&0xC0)>>6;
cardinfo->SD_csd.MaxRdCurrentVDDMin=(tmp&0x38)>>3;
cardinfo->SD_csd.MaxRdCurrentVDDMax=(tmp&0x07);
tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9個字節
cardinfo->SD_csd.MaxWrCurrentVDDMin=(tmp&0xE0)>>5;
cardinfo->SD_csd.MaxWrCurrentVDDMax=(tmp&0x1C)>>2;
cardinfo->SD_csd.DeviceSizeMul=(tmp&0x03)<<1;//C_SIZE_MULT
tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10個字節
cardinfo->SD_csd.DeviceSizeMul|=(tmp&0x80)>>7;
cardinfo->CardCapacity=(cardinfo->SD_csd.DeviceSize+1);//計算卡容量
cardinfo->CardCapacity*=(1<<(cardinfo->SD_csd.DeviceSizeMul+2));
cardinfo->CardBlockSize=1<<(cardinfo->SD_csd.RdBlockLen);//塊大小
cardinfo->CardCapacity*=cardinfo->CardBlockSize;
}else if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //高容量卡
{
tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7個字節
cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE
tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8個字節
cardinfo->SD_csd.DeviceSize|=(tmp<<8);
tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9個字節
cardinfo->SD_csd.DeviceSize|=(tmp);
tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10個字節
cardinfo->CardCapacity=(long long)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//計算卡容量
cardinfo->CardBlockSize=512; //塊大小固定為512字節
}
cardinfo->SD_csd.EraseGrSize=(tmp&0x40)>>6;
cardinfo->SD_csd.EraseGrMul=(tmp&0x3F)<<1;
tmp=(u8)(CSD_Tab[2]&0x000000FF); //第11個字節
cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7;
cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F);
tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24); //第12個字節
cardinfo->SD_csd.WrProtectGrEnable=(tmp&0x80)>>7;
cardinfo->SD_csd.ManDeflECC=(tmp&0x60)>>5;
cardinfo->SD_csd.WrSpeedFact=(tmp&0x1C)>>2;
cardinfo->SD_csd.MaxWrBlockLen=(tmp&0x03)<<2;
tmp=(u8)((CSD_Tab[3]&0x00FF0000)>>16); //第13個字節
cardinfo->SD_csd.MaxWrBlockLen|=(tmp&0xC0)>>6;
cardinfo->SD_csd.WriteBlockPaPartial=(tmp&0x20)>>5;
cardinfo->SD_csd.Reserved3=0;
cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01);
tmp=(u8)((CSD_Tab[3]&0x0000FF00)>>8); //第14個字節
cardinfo->SD_csd.FileFormatGrouop=(tmp&0x80)>>7;
cardinfo->SD_csd.CopyFlag=(tmp&0x40)>>6;
cardinfo->SD_csd.PermWrProtect=(tmp&0x20)>>5;
cardinfo->SD_csd.TempWrProtect=(tmp&0x10)>>4;
cardinfo->SD_csd.FileFormat=(tmp&0x0C)>>2;
cardinfo->SD_csd.ECC=(tmp&0x03);
tmp=(u8)(CSD_Tab[3]&0x000000FF); //第15個字節
cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1;
cardinfo->SD_csd.Reserved4=1;
tmp=(u8)((CID_Tab[0]&0xFF000000)>>24); //第0個字節
cardinfo->SD_cid.ManufacturerID=tmp;
tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16); //第1個字節
cardinfo->SD_cid.OEM_AppliID=tmp<<8;
tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8); //第2個字節
cardinfo->SD_cid.OEM_AppliID|=tmp;
tmp=(u8)(CID_Tab[0]&0x000000FF); //第3個字節
cardinfo->SD_cid.ProdName1=tmp<<24;
tmp=(u8)((CID_Tab[1]&0xFF000000)>>24); //第4個字節
cardinfo->SD_cid.ProdName1|=tmp<<16;
tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16); //第5個字節
cardinfo->SD_cid.ProdName1|=tmp<<8;
tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8); //第6個字節
cardinfo->SD_cid.ProdName1|=tmp;
tmp=(u8)(CID_Tab[1]&0x000000FF); //第7個字節
cardinfo->SD_cid.ProdName2=tmp;
tmp=(u8)((CID_Tab[2]&0xFF000000)>>24); //第8個字節
cardinfo->SD_cid.ProdRev=tmp;
tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16); //第9個字節
cardinfo->SD_cid.ProdSN=tmp<<24;
tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8); //第10個字節
cardinfo->SD_cid.ProdSN|=tmp<<16;
tmp=(u8)(CID_Tab[2]&0x000000FF); //第11個字節
cardinfo->SD_cid.ProdSN|=tmp<<8;
tmp=(u8)((CID_Tab[3]&0xFF000000)>>24); //第12個字節
cardinfo->SD_cid.ProdSN|=tmp;
tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16); //第13個字節
cardinfo->SD_cid.Reserved1|=(tmp&0xF0)>>4;
cardinfo->SD_cid.ManufactDate=(tmp&0x0F)<<8;
tmp=(u8)((CID_Tab[3]&0x0000FF00)>>8); //第14個字節
cardinfo->SD_cid.ManufactDate|=tmp;
tmp=(u8)(CID_Tab[3]&0x000000FF); //第15個字節
cardinfo->SD_cid.CID_CRC=(tmp&0xFE)>>1;
cardinfo->SD_cid.Reserved2=1;
return errorstatus;
}
//設置SDIO總線寬度(MMC卡不支持4bit模式)
//wmode:位寬模式.0,1位數據寬度;1,4位數據寬度;2,8位數據寬度
//返回值:SD卡錯誤狀態
//設置SDIO總線寬度(MMC卡不支持4bit模式)
// @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
// @arg SDIO_BusWide_4b: 4-bit data transfer
// @arg SDIO_BusWide_1b: 1-bit data transfer (默認)
//返回值:SD卡錯誤狀態
SD_Error SD_EnableWideBusOperation(u32 WideMode)
{
SD_Error errorstatus=SD_OK;
if (SDIO_MULTIMEDIA_CARD == CardType)
{
errorstatus = SD_UNSUPPORTED_FEATURE;
return(errorstatus);
}
else if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
if (SDIO_BusWide_8b == WideMode) //2.0 sd不支持8bits
{
errorstatus = SD_UNSUPPORTED_FEATURE;
return(errorstatus);
}
else
{
errorstatus=SDEnWideBus(WideMode);
if(SD_OK==errorstatus)
{
SDIO->CLKCR&=~(3<<11); //清除之前的位寬設置
SDIO->CLKCR|=WideMode;//1位/4位總線寬度
SDIO->CLKCR|=0<<14; //不開啟硬件流控制
}
}
}
return errorstatus;
}
//設置SD卡工作模式
//Mode:
//返回值:錯誤狀態
SD_Error SD_SetDeviceMode(u32 Mode)
{
SD_Error errorstatus = SD_OK;
if((Mode==SD_DMA_MODE)||(Mode==SD_POLLING_MODE))DeviceMode=Mode;
else errorstatus=SD_INVALID_PARAMETER;
return errorstatus;
}
//選卡
//發送CMD7,選擇相對地址(rca)為addr的卡,取消其他卡.如果為0,則都不選擇.
//addr:卡的RCA地址
SD_Error SD_SelectDeselect(u32 addr)
{
SDIO_CmdInitStructure.SDIO_Argument = addr;//發送CMD7,選擇卡,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEL_DESEL_CARD;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);//發送CMD7,選擇卡,短響應
return CmdResp1Error(SD_CMD_SEL_DESEL_CARD);
}
//SD卡讀取一個塊
//buf:讀數據緩存區(必須4字節對齊!!)
//addr:讀取地址
//blksize:塊大小
SD_Error SD_ReadBlock(u8 *buf,long long addr,u16 blksize)
{
SD_Error errorstatus=SD_OK;
u8 power;
u32 count=0,*tempbuff=(u32*)buf;//轉換為u32指針
u32 timeout=SDIO_DATATIMEOUT;
if(NULL==buf)
return SD_INVALID_PARAMETER;
SDIO->DCTRL=0x0; //數據控制寄存器清零(關DMA)
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
SDIO_DataInitStructure.SDIO_DataBlockSize= SDIO_DataBlockSize_1b ;//清除DPSM狀態機配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);//發送CMD16+設置數據長度為blksize,短響應
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4 ;//清除DPSM狀態機配置
SDIO_DataInitStructure.SDIO_DataLength= blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
SDIO_CmdInitStructure.SDIO_Argument = addr;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);//發送CMD17+從addr地址出讀取數據,短響應
errorstatus=CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
if(DeviceMode==SD_POLLING_MODE) //查詢模式,輪詢數據
{
INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<10)|(1<<9))))//無上溢/CRC/超時/完成(標志)/起始位錯誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET) //接收區半滿,表示至少存了8個字
{
for(count=0;count<8;count++) //循環讀取數據
{
*(tempbuff+count)=SDIO->FIFO;
}
tempbuff+=8;
timeout=0X7FFFFF; //讀數據溢出時間
}else //處理超時
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數據超時錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數據塊CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢錯誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清錯誤標志
return SD_RX_OVERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
return SD_START_BIT_ERR;
}
while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,還存在可用數據
{
*tempbuff=SDIO->FIFO; //循環讀取數據
tempbuff++;
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=0; //單塊讀,不需要發送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能
SD_DMA_Config((u32*)buf,blksize,DMA_DIR_PeripheralToMemory);
while(((DMA2->LISR&(1<<27))==RESET)&&(TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)return SD_DATA_TIMEOUT;//超時
if(TransferError!=SD_OK)errorstatus=TransferError;
}
return errorstatus;
}
//SD卡讀取多個塊
//buf:讀數據緩存區
//addr:讀取地址
//blksize:塊大小
//nblks:要讀取的塊數
//返回值:錯誤狀態
__align(4) u32 *tempbuff;
SD_Error SD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{
SD_Error errorstatus=SD_OK;
u8 power;
u32 count=0;
u32 timeout=SDIO_DATATIMEOUT;
tempbuff=(u32*)buf;//轉換為u32指針
SDIO->DCTRL=0x0; //數據控制寄存器清零(關DMA)
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM狀態機配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize;//發送CMD16+設置數據長度為blksize,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
if(nblks>1) //多塊讀
{
if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;//判斷是否超過最大接收長度
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ;//nblks*blksize,512塊大小,卡到控制器
SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
SDIO_CmdInitStructure.SDIO_Argument = addr;//發送CMD18+從addr地址出讀取數據,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_MULT_BLOCK;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_READ_MULT_BLOCK);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
if(DeviceMode==SD_POLLING_MODE)
{
INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<8)|(1<<9))))//無上溢/CRC/超時/完成(標志)/起始位錯誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET) //接收區半滿,表示至少存了8個字
{
for(count=0;count<8;count++) //循環讀取數據
{
*(tempbuff+count)=SDIO->FIFO;
}
tempbuff+=8;
timeout=0X7FFFFF; //讀數據溢出時間
}else //處理超時
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數據超時錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數據塊CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢錯誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清錯誤標志
return SD_RX_OVERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
return SD_START_BIT_ERR;
}
while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,還存在可用數據
{
*tempbuff=SDIO->FIFO; //循環讀取數據
tempbuff++;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET) //接收結束
{
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
SDIO_CmdInitStructure.SDIO_Argument = 0;//發送CMD12+結束傳輸
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
}
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=1; //多塊讀,需要發送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能
SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_PeripheralToMemory);
while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)return SD_DATA_TIMEOUT;//超時
while((TransferEnd==0)&&(TransferError==SD_OK));
if(TransferError!=SD_OK)errorstatus=TransferError;
}
}
return errorstatus;
}
//SD卡寫1個塊
//buf:數據緩存區
//addr:寫地址
//blksize:塊大小
//返回值:錯誤狀態
SD_Error SD_WriteBlock(u8 *buf,long long addr, u16 blksize)
{
SD_Error errorstatus = SD_OK;
u8 power=0,cardstate=0;
u32 timeout=0,bytestransferred=0;
u32 cardstatus=0,count=0,restwords=0;
u32 tlen=blksize; //總長度(字節)
u32*tempbuff=(u32*)buf;
if(buf==NULL)return SD_INVALID_PARAMETER;//參數錯誤
SDIO->DCTRL=0x0; //數據控制寄存器清零(關DMA)
SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM狀態機配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //大容量卡
{
blksize=512;
addr>>=9;
}
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize;//發送CMD16+設置數據長度為blksize,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//發送CMD13,查詢卡的狀態,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
cardstatus=SDIO->RESP1;
timeout=SD_DATATIMEOUT;
while(((cardstatus&0x00000100)==0)&&(timeout>0)) //檢查READY_FOR_DATA位是否置位
{
timeout--;
SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//發送CMD13,查詢卡的狀態,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
cardstatus=SDIO->RESP1;
}
if(timeout==0)return SD_ERROR;
SDIO_CmdInitStructure.SDIO_Argument = addr;//發送CMD24,寫單塊指令,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
StopCondition=0; //單塊寫,不需要發送停止傳輸指令
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡
SDIO_DataInitStructure.SDIO_DataLength= blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
timeout=SDIO_DATATIMEOUT;
if (DeviceMode == SD_POLLING_MODE)
{
INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<10)|(1<<4)|(1<<1)|(1<<3)|(1<<9))))//數據塊發送成功/下溢/CRC/超時/起始位錯誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET) //發送區半空,表示至少存了8個字
{
if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節了
{
restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
{
SDIO->FIFO=*tempbuff;
}
}else
{
for(count=0;count<8;count++)
{
SDIO->FIFO=*(tempbuff+count);
}
tempbuff+=8;
bytestransferred+=32;
}
timeout=0X3FFFFFFF; //寫數據溢出時間
}else
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數據超時錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數據塊CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢錯誤
{
SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清錯誤標志
return SD_TX_UNDERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
return SD_START_BIT_ERR;
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=0; //單塊寫,不需要發送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產生數據接收完成中斷
SD_DMA_Config((u32*)buf,blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置
SDIO->DCTRL|=1<<3; //SDIO DMA使能.
while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)
{
SD_Init(); //重新初始化SD卡,可以解決寫入死機的問題
return SD_DATA_TIMEOUT; //超時
}
timeout=SDIO_DATATIMEOUT;
while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
if(timeout==0)return SD_DATA_TIMEOUT; //超時
if(TransferError!=SD_OK)return TransferError;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
errorstatus=IsCardProgramming(&cardstate);
while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
{
errorstatus=IsCardProgramming(&cardstate);
}
return errorstatus;
}
//SD卡寫多個塊
//buf:數據緩存區
//addr:寫地址
//blksize:塊大小
//nblks:要寫入的塊數
//返回值:錯誤狀態
SD_Error SD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{
SD_Error errorstatus = SD_OK;
u8 power = 0, cardstate = 0;
u32 timeout=0,bytestransferred=0;
u32 count = 0, restwords = 0;
u32 tlen=nblks*blksize; //總長度(字節)
u32 *tempbuff = (u32*)buf;
if(buf==NULL)return SD_INVALID_PARAMETER; //參數錯誤
SDIO->DCTRL=0x0; //數據控制寄存器清零(關DMA)
SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ; //清除DPSM狀態機配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize; //發送CMD16+設置數據長度為blksize,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
if(nblks>1)
{
if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
//提高性能
SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16; //發送ACMD55,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
SDIO_CmdInitStructure.SDIO_Argument =nblks; //發送CMD23,設置塊數量,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCK_COUNT;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
}
SDIO_CmdInitStructure.SDIO_Argument =addr; //發送CMD25,多塊寫指令,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡
SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(DeviceMode==SD_POLLING_MODE)
{
timeout=SDIO_DATATIMEOUT;
INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/數據結束/超時/起始位錯誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET) //發送區半空,表示至少存了8字(32字節)
{
if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節了
{
restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
{
SDIO->FIFO=*tempbuff;
}
}else //發送區半空,可以發送至少8字(32字節)數據
{
for(count=0;count<SD_HALFFIFO;count++)
{
SDIO->FIFO=*(tempbuff+count);
}
tempbuff+=SD_HALFFIFO;
bytestransferred+=SD_HALFFIFOBYTES;
}
timeout=0X3FFFFFFF; //寫數據溢出時間
}else
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數據超時錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數據塊CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢錯誤
{
SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清錯誤標志
return SD_TX_UNDERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
return SD_START_BIT_ERR;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET) //發送結束
{
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
SDIO_CmdInitStructure.SDIO_Argument =0;//發送CMD12+結束傳輸
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
}
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=1; //多塊寫,需要發送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產生數據接收完成中斷
SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置
SDIO->DCTRL|=1<<3; //SDIO DMA使能.
timeout=SDIO_DATATIMEOUT;
while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0) //超時
{
SD_Init(); //重新初始化SD卡,可以解決寫入死機的問題
return SD_DATA_TIMEOUT; //超時
}
timeout=SDIO_DATATIMEOUT;
while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
if(timeout==0)return SD_DATA_TIMEOUT; //超時
if(TransferError!=SD_OK)return TransferError;
}
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
errorstatus=IsCardProgramming(&cardstate);
while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
{
errorstatus=IsCardProgramming(&cardstate);
}
return errorstatus;
}
//SDIO中斷服務函數
void SDIO_IRQHandler(void)
{
SD_ProcessIRQSrc();//處理所有SDIO相關中斷
}
//SDIO中斷處理函數
//處理SDIO傳輸過程中的各種中斷事務
//返回值:錯誤代碼
SD_Error SD_ProcessIRQSrc(void)
{
if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)//接收完成中斷
{
if (StopCondition==1)
{
SDIO_CmdInitStructure.SDIO_Argument =0;//發送CMD12+結束傳輸
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
TransferError=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);
}else TransferError = SD_OK;
SDIO->ICR|=1<<8;//清除完成中斷標記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferEnd = 1;
return(TransferError);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)//數據CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯誤標志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_DATA_CRC_FAIL;
return(SD_DATA_CRC_FAIL);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)//數據超時錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清中斷標志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_DATA_TIMEOUT;
return(SD_DATA_TIMEOUT);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)//FIFO上溢錯誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清中斷標志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_RX_OVERRUN;
return(SD_RX_OVERRUN);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)//FIFO下溢錯誤
{
SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清中斷標志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_TX_UNDERRUN;
return(SD_TX_UNDERRUN);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)//起始位錯誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR); //清中斷標志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_START_BIT_ERR;
return(SD_START_BIT_ERR);
}
return(SD_OK);
}
//檢查CMD0的執行狀態
//返回值:sd卡錯誤碼
SD_Error CmdError(void)
{
SD_Error errorstatus = SD_OK;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
if(SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) != RESET)break; //命令已發送(無需響應)
}
if(timeout==0)return SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
return errorstatus;
}
//檢查R7響應的錯誤狀態
//返回值:sd卡錯誤碼
SD_Error CmdResp7Error(void)
{
SD_Error errorstatus=SD_OK;
u32 status;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經收到響應(CRC校驗成功)
}
if((timeout==0)||(status&(1<<2))) //響應超時
{
errorstatus=SD_CMD_RSP_TIMEOUT; //當前卡不是2.0兼容卡,或者不支持設定的電壓范圍
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應超時標志
return errorstatus;
}
if(status&1<<6) //成功接收到響應
{
errorstatus=SD_OK;
SDIO_ClearFlag(SDIO_FLAG_CMDREND); //清除響應標志
}
return errorstatus;
}
//檢查R1響應的錯誤狀態
//cmd:當前命令
//返回值:sd卡錯誤碼
SD_Error CmdResp1Error(u8 cmd)
{
u32 status;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經收到響應(CRC校驗成功)
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //響應超時
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應超時標志
return SD_CMD_RSP_TIMEOUT;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除標志
return SD_CMD_CRC_FAIL;
}
if(SDIO->RESPCMD!=cmd)return SD_ILLEGAL_CMD;//命令不匹配
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
return (SD_Error)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡響應
}
//檢查R3響應的錯誤狀態
//返回值:錯誤狀態
SD_Error CmdResp3Error(void)
{
u32 status;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經收到響應(CRC校驗成功)
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //響應超時
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應超時標志
return SD_CMD_RSP_TIMEOUT;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
return SD_OK;
}
//檢查R2響應的錯誤狀態
//返回值:錯誤狀態
SD_Error CmdResp2Error(void)
{
SD_Error errorstatus=SD_OK;
u32 status;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經收到響應(CRC校驗成功)
}
if((timeout==0)||(status&(1<<2))) //響應超時
{
errorstatus=SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應超時標志
return errorstatus;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC錯誤
{
errorstatus=SD_CMD_CRC_FAIL;
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除響應標志
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
return errorstatus;
}
//檢查R6響應的錯誤狀態
//cmd:之前發送的命令
//prca:卡返回的RCA地址
//返回值:錯誤狀態
SD_Error CmdResp6Error(u8 cmd,u16*prca)
{
SD_Error errorstatus=SD_OK;
u32 status;
u32 rspr1;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經收到響應(CRC校驗成功)
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //響應超時
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應超時標志
return SD_CMD_RSP_TIMEOUT;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除響應標志
return SD_CMD_CRC_FAIL;
}
if(SDIO->RESPCMD!=cmd) //判斷是否響應cmd命令
{
return SD_ILLEGAL_CMD;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
rspr1=SDIO->RESP1; //得到響應
if(SD_ALLZERO==(rspr1&(SD_R6_GENERAL_UNKNOWN_ERROR|SD_R6_ILLEGAL_CMD|SD_R6_COM_CRC_FAILED)))
{
*prca=(u16)(rspr1>>16); //右移16位得到,rca
return errorstatus;
}
if(rspr1&SD_R6_GENERAL_UNKNOWN_ERROR)return SD_GENERAL_UNKNOWN_ERROR;
if(rspr1&SD_R6_ILLEGAL_CMD)return SD_ILLEGAL_CMD;
if(rspr1&SD_R6_COM_CRC_FAILED)return SD_COM_CRC_FAILED;
return errorstatus;
}
//SDIO使能寬總線模式
//enx:0,不使能;1,使能;
//返回值:錯誤狀態
SD_Error SDEnWideBus(u8 enx)
{
SD_Error errorstatus = SD_OK;
u32 scr[2]={0,0};
u8 arg=0X00;
if(enx)arg=0X02;
else arg=0X00;
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//SD卡處於LOCKED狀態
errorstatus=FindSCR(RCA,scr); //得到SCR寄存器數據
if(errorstatus!=SD_OK)return errorstatus;
if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO) //支持寬總線
{
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//發送CMD55+RCA,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_APP_CMD);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_CmdInitStructure.SDIO_Argument = arg;//發送ACMD6,短響應,參數:10,4位;00,1位.
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);
return errorstatus;
}else return SD_REQUEST_NOT_APPLICABLE; //不支持寬總線設置
}
//檢查卡是否正在執行寫操作
//pstatus:當前狀態.
//返回值:錯誤代碼
SD_Error IsCardProgramming(u8 *pstatus)
{
vu32 respR1 = 0, status = 0;
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16; //卡相對地址參數
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;//發送CMD13
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
status=SDIO->STA;
while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC檢測失敗
{
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除錯誤標記
return SD_CMD_CRC_FAIL;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //命令超時
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除錯誤標記
return SD_CMD_RSP_TIMEOUT;
}
if(SDIO->RESPCMD!=SD_CMD_SEND_STATUS)return SD_ILLEGAL_CMD;
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
respR1=SDIO->RESP1;
*pstatus=(u8)((respR1>>9)&0x0000000F);
return SD_OK;
}
//讀取當前卡狀態
//pcardstatus:卡狀態
//返回值:錯誤代碼
SD_Error SD_SendStatus(uint32_t *pcardstatus)
{
SD_Error errorstatus = SD_OK;
if(pcardstatus==NULL)
{
errorstatus=SD_INVALID_PARAMETER;
return errorstatus;
}
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//發送CMD13,短響應
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //查詢響應狀態
if(errorstatus!=SD_OK)return errorstatus;
*pcardstatus=SDIO->RESP1;//讀取響應值
return errorstatus;
}
//返回SD卡的狀態
//返回值:SD卡狀態
SDCardState SD_GetState(void)
{
u32 resp1=0;
if(SD_SendStatus(&resp1)!=SD_OK)return SD_CARD_ERROR;
else return (SDCardState)((resp1>>9) & 0x0F);
}
//查找SD卡的SCR寄存器值
//rca:卡相對地址
//pscr:數據緩存區(存儲SCR內容)
//返回值:錯誤狀態
SD_Error FindSCR(u16 rca,u32 *pscr)
{
u32 index = 0;
SD_Error errorstatus = SD_OK;
u32 tempscr[2]={0,0};
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)8; //發送CMD16,短響應,設置Block Size為8字節
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN; // cmd16
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r1
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;//發送CMD55,短響應
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_APP_CMD);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
SDIO_DataInitStructure.SDIO_DataLength = 8; //8個字節長度,block為8字節,SD卡到SDIO.
SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b ; //塊大小8byte
SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
SDIO_DataConfig(&SDIO_DataInitStructure);
SDIO_CmdInitStructure.SDIO_Argument = 0x0;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_SEND_SCR; //發送ACMD51,短響應,參數為0
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r1
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SD_APP_SEND_SCR);
if(errorstatus!=SD_OK)return errorstatus;
while(!(SDIO->STA&(SDIO_FLAG_RXOVERR|SDIO_FLAG_DCRCFAIL|SDIO_FLAG_DTIMEOUT|SDIO_FLAG_DBCKEND|SDIO_FLAG_STBITERR)))
{
if(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)//接收FIFO數據可用
{
*(tempscr+index)=SDIO->FIFO; //讀取FIFO內容
index++;
if(index>=2)break;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數據超時錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數據塊CRC錯誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢錯誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清錯誤標志
return SD_RX_OVERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
return SD_START_BIT_ERR;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
//把數據順序按8位為單位倒過來.
*(pscr+1)=((tempscr[0]&SD_0TO7BITS)<<24)|((tempscr[0]&SD_8TO15BITS)<<8)|((tempscr[0]&SD_16TO23BITS)>>8)|((tempscr[0]&SD_24TO31BITS)>>24);
*(pscr)=((tempscr[1]&SD_0TO7BITS)<<24)|((tempscr[1]&SD_8TO15BITS)<<8)|((tempscr[1]&SD_16TO23BITS)>>8)|((tempscr[1]&SD_24TO31BITS)>>24);
return errorstatus;
}
//得到NumberOfBytes以2為底的指數.
//NumberOfBytes:字節數.
//返回值:以2為底的指數值
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes)
{
u8 count=0;
while(NumberOfBytes!=1)
{
NumberOfBytes>>=1;
count++;
}
return count;
}
//配置SDIO DMA
//mbuf:存儲器地址
//bufsize:傳輸數據量
//dir:方向;DMA_DIR_MemoryToPeripheral 存儲器-->SDIO(寫數據);DMA_DIR_PeripheralToMemory SDIO-->存儲器(讀數據);
void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir)
{
DMA_InitTypeDef DMA_InitStructure;
while (DMA_GetCmdStatus(DMA2_Stream3) != DISABLE){}//等待DMA可配置
DMA_DeInit(DMA2_Stream3);//清空之前該stream3上的所有中斷標志
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道選擇
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SDIO->FIFO;//DMA外設地址
DMA_InitStructure.DMA_Memory0BaseAddr = (u32)mbuf;//DMA 存儲器0地址
DMA_InitStructure.DMA_DIR = dir;//存儲器到外設模式
DMA_InitStructure.DMA_BufferSize = 0;//數據傳輸量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外設非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//存儲器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;//外設數據長度:32位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;//存儲器數據長度:32位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;//最高優先級
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; //FIFO使能
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;//全FIFO
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;//外設突發4次傳輸
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;//存儲器突發4次傳輸
DMA_Init(DMA2_Stream3, &DMA_InitStructure);//初始化DMA Stream
DMA_FlowControllerConfig(DMA2_Stream3,DMA_FlowCtrl_Peripheral);//外設流控制
DMA_Cmd(DMA2_Stream3 ,ENABLE);//開啟DMA傳輸
}
//讀SD卡
//buf:讀數據緩存區
//sector:扇區地址
//cnt:扇區個數
//返回值:錯誤狀態;0,正常;其他,錯誤代碼;
u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt)
{
u8 sta=SD_OK;
long long lsector=sector;
u8 n;
lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
sta=SD_ReadBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個sector的讀操作
memcpy(buf,SDIO_DATA_BUFFER,512);
buf+=512;
}
}else
{
if(cnt==1)sta=SD_ReadBlock(buf,lsector,512); //單個sector的讀操作
else sta=SD_ReadMultiBlocks(buf,lsector,512,cnt);//多個sector
}
return sta;
}
//寫SD卡
//buf:寫數據緩存區
//sector:扇區地址
//cnt:扇區個數
//返回值:錯誤狀態;0,正常;其他,錯誤代碼;
u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt)
{
u8 sta=SD_OK;
u8 n;
long long lsector=sector;
lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
memcpy(SDIO_DATA_BUFFER,buf,512);
sta=SD_WriteBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個sector的寫操作
buf+=512;
}
}else
{
if(cnt==1)sta=SD_WriteBlock(buf,lsector,512); //單個sector的寫操作
else sta=SD_WriteMultiBlocks(buf,lsector,512,cnt); //多個sector
}
return sta;
}
這是頭文件《sdio_sdcard.h》
#ifndef __SDIO_SDCARD_H
#define __SDIO_SDCARD_H
#include "stm32f4xx.h"
//SDIO相關標志位,拷貝自:stm32f4xx_sdio.h
#define SDIO_FLAG_CCRCFAIL ((uint32_t)0x00000001)
#define SDIO_FLAG_DCRCFAIL ((uint32_t)0x00000002)
#define SDIO_FLAG_CTIMEOUT ((uint32_t)0x00000004)
#define SDIO_FLAG_DTIMEOUT ((uint32_t)0x00000008)
#define SDIO_FLAG_TXUNDERR ((uint32_t)0x00000010)
#define SDIO_FLAG_RXOVERR ((uint32_t)0x00000020)
#define SDIO_FLAG_CMDREND ((uint32_t)0x00000040)
#define SDIO_FLAG_CMDSENT ((uint32_t)0x00000080)
#define SDIO_FLAG_DATAEND ((uint32_t)0x00000100)
#define SDIO_FLAG_STBITERR ((uint32_t)0x00000200)
#define SDIO_FLAG_DBCKEND ((uint32_t)0x00000400)
#define SDIO_FLAG_CMDACT ((uint32_t)0x00000800)
#define SDIO_FLAG_TXACT ((uint32_t)0x00001000)
#define SDIO_FLAG_RXACT ((uint32_t)0x00002000)
#define SDIO_FLAG_TXFIFOHE ((uint32_t)0x00004000)
#define SDIO_FLAG_RXFIFOHF ((uint32_t)0x00008000)
#define SDIO_FLAG_TXFIFOF ((uint32_t)0x00010000)
#define SDIO_FLAG_RXFIFOF ((uint32_t)0x00020000)
#define SDIO_FLAG_TXFIFOE ((uint32_t)0x00040000)
#define SDIO_FLAG_RXFIFOE ((uint32_t)0x00080000)
#define SDIO_FLAG_TXDAVL ((uint32_t)0x00100000)
#define SDIO_FLAG_RXDAVL ((uint32_t)0x00200000)
#define SDIO_FLAG_SDIOIT ((uint32_t)0x00400000)
#define SDIO_FLAG_CEATAEND ((uint32_t)0x00800000)
//用戶配置區
//SDIO時鍾計算公式:SDIO_CK時鍾=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定為48Mhz
//使用DMA模式的時候,傳輸速率可以到48Mhz(bypass on時),不過如果你的卡不是高速
//卡,可能也會出錯,出錯就請降低時鍾
#define SDIO_INIT_CLK_DIV 0x76 //SDIO初始化頻率，最大400Kh
#define SDIO_TRANSFER_CLK_DIV 0x00 //SDIO傳輸頻率,該值太小可能會導致讀寫文件出錯
////////////////////////////////////////////////////////////////////////////////////////////////////
//SDIO工作模式定義,通過SD_SetDeviceMode函數設置.
#define SD_POLLING_MODE 0 //查詢模式,該模式下,如果讀寫有問題,建議增大SDIO_TRANSFER_CLK_DIV的設置.
#define SD_DMA_MODE 1 //DMA模式,該模式下,如果讀寫有問題,建議增大SDIO_TRANSFER_CLK_DIV的設置.
//SDIO 各種錯誤枚舉定義
typedef enum
{
//特殊錯誤定義
SD_CMD_CRC_FAIL = (1), /*!< Command response received (but CRC check failed) */
SD_DATA_CRC_FAIL = (2), /*!< Data bock sent/received (CRC check Failed) */
SD_CMD_RSP_TIMEOUT = (3), /*!< Command response timeout */
SD_DATA_TIMEOUT = (4), /*!< Data time out */
SD_TX_UNDERRUN = (5), /*!< Transmit FIFO under-run */
SD_RX_OVERRUN = (6), /*!< Receive FIFO over-run */
SD_START_BIT_ERR = (7), /*!< Start bit not detected on all data signals in widE bus mode */
SD_CMD_OUT_OF_RANGE = (8), /*!< CMD's argument was out of range.*/
SD_ADDR_MISALIGNED = (9), /*!< Misaligned address */
SD_BLOCK_LEN_ERR = (10), /*!< Transferred block length is not allowed for the card or the number of transferred bytes does not match the block length */
SD_ERASE_SEQ_ERR = (11), /*!< An error in the sequence of erase command occurs.*/
SD_BAD_ERASE_PARAM = (12), /*!< An Invalid selection for erase groups */
SD_WRITE_PROT_VIOLATION = (13), /*!< Attempt to program a write protect block */
SD_LOCK_UNLOCK_FAILED = (14), /*!< Sequence or password error has been detected in unlock command or if there was an attempt to access a locked card */
SD_COM_CRC_FAILED = (15), /*!< CRC check of the previous command failed */
SD_ILLEGAL_CMD = (16), /*!< Command is not legal for the card state */
SD_CARD_ECC_FAILED = (17), /*!< Card internal ECC was applied but failed to correct the data */
SD_CC_ERROR = (18), /*!< Internal card controller error */
SD_GENERAL_UNKNOWN_ERROR = (19), /*!< General or Unknown error */
SD_STREAM_READ_UNDERRUN = (20), /*!< The card could not sustain data transfer in stream read operation. */
SD_STREAM_WRITE_OVERRUN = (21), /*!< The card could not sustain data programming in stream mode */
SD_CID_CSD_OVERWRITE = (22), /*!< CID/CSD overwrite error */
SD_WP_ERASE_SKIP = (23), /*!< only partial address space was erased */
SD_CARD_ECC_DISABLED = (24), /*!< Command has been executed without using internal ECC */
SD_ERASE_RESET = (25), /*!< Erase sequence was cleared before executing because an out of erase sequence command was received */
SD_AKE_SEQ_ERROR = (26), /*!< Error in sequence of authentication. */
SD_INVALID_VOLTRANGE = (27),
SD_ADDR_OUT_OF_RANGE = (28),
SD_SWITCH_ERROR = (29),
SD_SDIO_DISABLED = (30),
SD_SDIO_FUNCTION_BUSY = (31),
SD_SDIO_FUNCTION_FAILED = (32),
SD_SDIO_UNKNOWN_FUNCTION = (33),
//標准錯誤定義
SD_INTERNAL_ERROR,
SD_NOT_CONFIGURED,
SD_REQUEST_PENDING,
SD_REQUEST_NOT_APPLICABLE,
SD_INVALID_PARAMETER,
SD_UNSUPPORTED_FEATURE,
SD_UNSUPPORTED_HW,
SD_ERROR,
SD_OK = 0
} SD_Error;
//SD卡CSD寄存器數據
typedef struct
{
u8 CSDStruct; /*!< CSD structure */
u8 SysSpecVersion; /*!< System specification version */
u8 Reserved1; /*!< Reserved */
u8 TAAC; /*!< Data read access-time 1 */
u8 NSAC; /*!< Data read access-time 2 in CLK cycles */
u8 MaxBusClkFrec; /*!< Max. bus clock frequency */
u16 CardComdClasses; /*!< Card command classes */
u8 RdBlockLen; /*!< Max. read data block length */
u8 PartBlockRead; /*!< Partial blocks for read allowed */
u8 WrBlockMisalign; /*!< Write block misalignment */
u8 RdBlockMisalign; /*!< Read block misalignment */
u8 DSRImpl; /*!< DSR implemented */
u8 Reserved2; /*!< Reserved */
u32 DeviceSize; /*!< Device Size */
u8 MaxRdCurrentVDDMin; /*!< Max. read current @ VDD min */
u8 MaxRdCurrentVDDMax; /*!< Max. read current @ VDD max */
u8 MaxWrCurrentVDDMin; /*!< Max. write current @ VDD min */
u8 MaxWrCurrentVDDMax; /*!< Max. write current @ VDD max */
u8 DeviceSizeMul; /*!< Device size multiplier */
u8 EraseGrSize; /*!< Erase group size */
u8 EraseGrMul; /*!< Erase group size multiplier */
u8 WrProtectGrSize; /*!< Write protect group size */
u8 WrProtectGrEnable; /*!< Write protect group enable */
u8 ManDeflECC; /*!< Manufacturer default ECC */
u8 WrSpeedFact; /*!< Write speed factor */
u8 MaxWrBlockLen; /*!< Max. write data block length */
u8 WriteBlockPaPartial; /*!< Partial blocks for write allowed */
u8 Reserved3; /*!< Reserded */
u8 ContentProtectAppli; /*!< Content protection application */
u8 FileFormatGrouop; /*!< File format group */
u8 CopyFlag; /*!< Copy flag (OTP) */
u8 PermWrProtect; /*!< Permanent write protection */
u8 TempWrProtect; /*!< Temporary write protection */
u8 FileFormat; /*!< File Format */
u8 ECC; /*!< ECC code */
u8 CSD_CRC; /*!< CSD CRC */
u8 Reserved4; /*!< always 1*/
} SD_CSD;
//SD卡CID寄存器數據
typedef struct
{
u8 ManufacturerID; /*!< ManufacturerID */
u16 OEM_AppliID; /*!< OEM/Application ID */
u32 ProdName1; /*!< Product Name part1 */
u8 ProdName2; /*!< Product Name part2*/
u8 ProdRev; /*!< Product Revision */
u32 ProdSN; /*!< Product Serial Number */
u8 Reserved1; /*!< Reserved1 */
u16 ManufactDate; /*!< Manufacturing Date */
u8 CID_CRC; /*!< CID CRC */
u8 Reserved2; /*!< always 1 */
} SD_CID;
//SD卡狀態
typedef enum
{
SD_CARD_READY = ((uint32_t)0x00000001),
SD_CARD_IDENTIFICATION = ((uint32_t)0x00000002),
SD_CARD_STANDBY = ((uint32_t)0x00000003),
SD_CARD_TRANSFER = ((uint32_t)0x00000004),
SD_CARD_SENDING = ((uint32_t)0x00000005),
SD_CARD_RECEIVING = ((uint32_t)0x00000006),
SD_CARD_PROGRAMMING = ((uint32_t)0x00000007),
SD_CARD_DISCONNECTED = ((uint32_t)0x00000008),
SD_CARD_ERROR = ((uint32_t)0x000000FF)
}SDCardState;
//SD卡信息,包括CSD,CID等數據
typedef struct
{
SD_CSD SD_csd;
SD_CID SD_cid;
long long CardCapacity; //SD卡容量,單位:字節,最大支持2^64字節大小的卡.
u32 CardBlockSize; //SD卡塊大小
u16 RCA; //卡相對地址
u8 CardType; //卡類型
} SD_CardInfo;
extern SD_CardInfo SDCardInfo;//SD卡信息
////////////////////////////////////////////////////////////////////////////////////////////////////
//SDIO 指令集
#define SD_CMD_GO_IDLE_STATE ((u8)0)
#define SD_CMD_SEND_OP_COND ((u8)1)
#define SD_CMD_ALL_SEND_CID ((u8)2)
#define SD_CMD_SET_REL_ADDR ((u8)3) /*!< SDIO_SEND_REL_ADDR for SD Card */
#define SD_CMD_SET_DSR ((u8)4)
#define SD_CMD_SDIO_SEN_OP_COND ((u8)5)
#define SD_CMD_HS_SWITCH ((u8)6)
#define SD_CMD_SEL_DESEL_CARD ((u8)7)
#define SD_CMD_HS_SEND_EXT_CSD ((u8)8)
#define SD_CMD_SEND_CSD ((u8)9)
#define SD_CMD_SEND_CID ((u8)10)
#define SD_CMD_READ_DAT_UNTIL_STOP ((u8)11) /*!< SD Card doesn't support it */
#define SD_CMD_STOP_TRANSMISSION ((u8)12)
#define SD_CMD_SEND_STATUS ((u8)13)
#define SD_CMD_HS_BUSTEST_READ ((u8)14)
#define SD_CMD_GO_INACTIVE_STATE ((u8)15)
#define SD_CMD_SET_BLOCKLEN ((u8)16)
#define SD_CMD_READ_SINGLE_BLOCK ((u8)17)
#define SD_CMD_READ_MULT_BLOCK ((u8)18)
#define SD_CMD_HS_BUSTEST_WRITE ((u8)19)
#define SD_CMD_WRITE_DAT_UNTIL_STOP ((u8)20)
#define SD_CMD_SET_BLOCK_COUNT ((u8)23)
#define SD_CMD_WRITE_SINGLE_BLOCK ((u8)24)
#define SD_CMD_WRITE_MULT_BLOCK ((u8)25)
#define SD_CMD_PROG_CID ((u8)26)
#define SD_CMD_PROG_CSD ((u8)27)
#define SD_CMD_SET_WRITE_PROT ((u8)28)
#define SD_CMD_CLR_WRITE_PROT ((u8)29)
#define SD_CMD_SEND_WRITE_PROT ((u8)30)
#define SD_CMD_SD_ERASE_GRP_START ((u8)32) /*!< To set the address of the first write
block to be erased. (For SD card only) */
#define SD_CMD_SD_ERASE_GRP_END ((u8)33) /*!< To set the address of the last write block of the
continuous range to be erased. (For SD card only) */
#define SD_CMD_ERASE_GRP_START ((u8)35) /*!< To set the address of the first write block to be erased.
(For MMC card only spec 3.31) */
#define SD_CMD_ERASE_GRP_END ((u8)36) /*!< To set the address of the last write block of the
continuous range to be erased. (For MMC card only spec 3.31) */
#define SD_CMD_ERASE ((u8)38)
#define SD_CMD_FAST_IO ((u8)39) /*!< SD Card doesn't support it */
#define SD_CMD_GO_IRQ_STATE ((u8)40) /*!< SD Card doesn't support it */
#define SD_CMD_LOCK_UNLOCK ((u8)42)
#define SD_CMD_APP_CMD ((u8)55)
#define SD_CMD_GEN_CMD ((u8)56)
#define SD_CMD_NO_CMD ((u8)64)
/**
* @brief Following commands are SD Card Specific commands.
* SDIO_APP_CMD ：CMD55 should be sent before sending these commands.
*/
#define SD_CMD_APP_SD_SET_BUSWIDTH ((u8)6) /*!< For SD Card only */
#define SD_CMD_SD_APP_STAUS ((u8)13) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS ((u8)22) /*!< For SD Card only */
#define SD_CMD_SD_APP_OP_COND ((u8)41) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT ((u8)42) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_SCR ((u8)51) /*!< For SD Card only */
#define SD_CMD_SDIO_RW_DIRECT ((u8)52) /*!< For SD I/O Card only */
#define SD_CMD_SDIO_RW_EXTENDED ((u8)53) /*!< For SD I/O Card only */
/**
* @brief Following commands are SD Card Specific security commands.
* SDIO_APP_CMD should be sent before sending these commands.
*/
#define SD_CMD_SD_APP_GET_MKB ((u8)43) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_MID ((u8)44) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RN1 ((u8)45) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RN2 ((u8)46) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RES2 ((u8)47) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RES1 ((u8)48) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK ((u8)18) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK ((u8)25) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_ERASE ((u8)38) /*!< For SD Card only */
#define SD_CMD_SD_APP_CHANGE_SECURE_AREA ((u8)49) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MKB ((u8)48) /*!< For SD Card only */
//支持的SD卡定義
#define SDIO_STD_CAPACITY_SD_CARD_V1_1 ((u32)0x00000000)
#define SDIO_STD_CAPACITY_SD_CARD_V2_0 ((u32)0x00000001)
#define SDIO_HIGH_CAPACITY_SD_CARD ((u32)0x00000002)
#define SDIO_MULTIMEDIA_CARD ((u32)0x00000003)
#define SDIO_SECURE_DIGITAL_IO_CARD ((u32)0x00000004)
#define SDIO_HIGH_SPEED_MULTIMEDIA_CARD ((u32)0x00000005)
#define SDIO_SECURE_DIGITAL_IO_COMBO_CARD ((u32)0x00000006)
#define SDIO_HIGH_CAPACITY_MMC_CARD ((u32)0x00000007)
//SDIO相關參數定義
#define NULL 0
#define SDIO_STATIC_FLAGS ((u32)0x000005FF)
#define SDIO_CMD0TIMEOUT ((u32)0x00010000)
#define SDIO_DATATIMEOUT ((u32)0xFFFFFFFF)
#define SDIO_FIFO_Address ((u32)0x40018080)
//Mask for errors Card Status R1 (OCR Register)
#define SD_OCR_ADDR_OUT_OF_RANGE ((u32)0x80000000)
#define SD_OCR_ADDR_MISALIGNED ((u32)0x40000000)
#define SD_OCR_BLOCK_LEN_ERR ((u32)0x20000000)
#define SD_OCR_ERASE_SEQ_ERR ((u32)0x10000000)
#define SD_OCR_BAD_ERASE_PARAM ((u32)0x08000000)
#define SD_OCR_WRITE_PROT_VIOLATION ((u32)0x04000000)
#define SD_OCR_LOCK_UNLOCK_FAILED ((u32)0x01000000)
#define SD_OCR_COM_CRC_FAILED ((u32)0x00800000)
#define SD_OCR_ILLEGAL_CMD ((u32)0x00400000)
#define SD_OCR_CARD_ECC_FAILED ((u32)0x00200000)
#define SD_OCR_CC_ERROR ((u32)0x00100000)
#define SD_OCR_GENERAL_UNKNOWN_ERROR ((u32)0x00080000)
#define SD_OCR_STREAM_READ_UNDERRUN ((u32)0x00040000)
#define SD_OCR_STREAM_WRITE_OVERRUN ((u32)0x00020000)
#define SD_OCR_CID_CSD_OVERWRIETE ((u32)0x00010000)
#define SD_OCR_WP_ERASE_SKIP ((u32)0x00008000)
#define SD_OCR_CARD_ECC_DISABLED ((u32)0x00004000)
#define SD_OCR_ERASE_RESET ((u32)0x00002000)
#define SD_OCR_AKE_SEQ_ERROR ((u32)0x00000008)
#define SD_OCR_ERRORBITS ((u32)0xFDFFE008)
//Masks for R6 Response
#define SD_R6_GENERAL_UNKNOWN_ERROR ((u32)0x00002000)
#define SD_R6_ILLEGAL_CMD ((u32)0x00004000)
#define SD_R6_COM_CRC_FAILED ((u32)0x00008000)
#define SD_VOLTAGE_WINDOW_SD ((u32)0x80100000)
#define SD_HIGH_CAPACITY ((u32)0x40000000)
#define SD_STD_CAPACITY ((u32)0x00000000)
#define SD_CHECK_PATTERN ((u32)0x000001AA)
#define SD_VOLTAGE_WINDOW_MMC ((u32)0x80FF8000)
#define SD_MAX_VOLT_TRIAL ((u32)0x0000FFFF)
#define SD_ALLZERO ((u32)0x00000000)
#define SD_WIDE_BUS_SUPPORT ((u32)0x00040000)
#define SD_SINGLE_BUS_SUPPORT ((u32)0x00010000)
#define SD_CARD_LOCKED ((u32)0x02000000)
#define SD_CARD_PROGRAMMING ((u32)0x00000007)
#define SD_CARD_RECEIVING ((u32)0x00000006)
#define SD_DATATIMEOUT ((u32)0xFFFFFFFF)
#define SD_0TO7BITS ((u32)0x000000FF)
#define SD_8TO15BITS ((u32)0x0000FF00)
#define SD_16TO23BITS ((u32)0x00FF0000)
#define SD_24TO31BITS ((u32)0xFF000000)
#define SD_MAX_DATA_LENGTH ((u32)0x01FFFFFF)
#define SD_HALFFIFO ((u32)0x00000008)
#define SD_HALFFIFOBYTES ((u32)0x00000020)
//Command Class Supported
#define SD_CCCC_LOCK_UNLOCK ((u32)0x00000080)
#define SD_CCCC_WRITE_PROT ((u32)0x00000040)
#define SD_CCCC_ERASE ((u32)0x00000020)
//CMD8指令
#define SDIO_SEND_IF_COND ((u32)0x00000008)
////////////////////////////////////////////////////////////////////////////////////////////////////
//相關函數定義
SD_Error SD_Init(void);
void SDIO_Clock_Set(u8 clkdiv);
SD_Error SD_PowerON(void);
SD_Error SD_PowerOFF(void);
SD_Error SD_InitializeCards(void);
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo);
SD_Error SD_EnableWideBusOperation(u32 wmode);
SD_Error SD_SetDeviceMode(u32 mode);
SD_Error SD_SelectDeselect(u32 addr);
SD_Error SD_SendStatus(uint32_t *pcardstatus);
SDCardState SD_GetState(void);
SD_Error SD_ReadBlock(u8 *buf,long long addr,u16 blksize);
SD_Error SD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SD_Error SD_WriteBlock(u8 *buf,long long addr, u16 blksize);
SD_Error SD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SD_Error SD_ProcessIRQSrc(void);
void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir);
//void SD_DMA_Config(u32*mbuf,u32 bufsize,u8 dir);
u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt); //讀SD卡,fatfs/usb調用
u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt); //寫SD卡,fatfs/usb調用
#endif