AMiRo-OS

/****************************************************************************************

| Project Name: Application Development using the Olimex STM32-E407 board

|  Description: Disk I/O source file for FatFS configured for an MMC card on SDIO.

|    File Name: mmc.c

|        Notes: The SDIO interface was derived from the SDCARD example that comes with

|               the Standard Peripheral Library from STMicroelectronics as falls under

|               their copyright and license. By using this file you agree to:

|

|                   COPYRIGHT 2013 STMicroelectronics

|

|        Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");

|        You may not use this file except in compliance with the License.

|        You may obtain a copy of the License at:

|   

|             http://www.st.com/software_license_agreement_liberty_v2

|   

|        Unless required by applicable law or agreed to in writing, software 

|        distributed under the License is distributed on an "AS IS" BASIS, 

|        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

|        See the License for the specific language governing permissions and

|        limitations under the License.

|

|****************************************************************************************/

/****************************************************************************************

* Include files

****************************************************************************************/

#include <string.h> 

#include "diskio.h"

#include "stm32f4xx.h"

/****************************************************************************************

* Type definitions

****************************************************************************************/

/** 

  * @brief  SDIO specific error defines  

  */   

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),

/** 

  * @brief  Standard error defines   

  */ 

  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;

/** 

  * @brief  SDIO Transfer state  

  */   

typedef enum

{

  SD_TRANSFER_OK  = 0,

  SD_TRANSFER_BUSY = 1,

  SD_TRANSFER_ERROR

} SDTransferState;

/** 

  * @brief  SD Card States 

  */   

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;

/** 

  * @brief  Card Specific Data: CSD Register   

  */ 

typedef struct

{

  __IO uint8_t  CSDStruct;            /*!< CSD structure */

  __IO uint8_t  SysSpecVersion;       /*!< System specification version */

  __IO uint8_t  Reserved1;            /*!< Reserved */

  __IO uint8_t  TAAC;                 /*!< Data read access-time 1 */

  __IO uint8_t  NSAC;                 /*!< Data read access-time 2 in CLK cycles */

  __IO uint8_t  MaxBusClkFrec;        /*!< Max. bus clock frequency */

  __IO uint16_t CardComdClasses;      /*!< Card command classes */

  __IO uint8_t  RdBlockLen;           /*!< Max. read data block length */

  __IO uint8_t  PartBlockRead;        /*!< Partial blocks for read allowed */

  __IO uint8_t  WrBlockMisalign;      /*!< Write block misalignment */

  __IO uint8_t  RdBlockMisalign;      /*!< Read block misalignment */

  __IO uint8_t  DSRImpl;              /*!< DSR implemented */

  __IO uint8_t  Reserved2;            /*!< Reserved */

  __IO uint32_t DeviceSize;           /*!< Device Size */

  __IO uint8_t  MaxRdCurrentVDDMin;   /*!< Max. read current @ VDD min */

  __IO uint8_t  MaxRdCurrentVDDMax;   /*!< Max. read current @ VDD max */

  __IO uint8_t  MaxWrCurrentVDDMin;   /*!< Max. write current @ VDD min */

  __IO uint8_t  MaxWrCurrentVDDMax;   /*!< Max. write current @ VDD max */

  __IO uint8_t  DeviceSizeMul;        /*!< Device size multiplier */

  __IO uint8_t  EraseGrSize;          /*!< Erase group size */

  __IO uint8_t  EraseGrMul;           /*!< Erase group size multiplier */

  __IO uint8_t  WrProtectGrSize;      /*!< Write protect group size */

  __IO uint8_t  WrProtectGrEnable;    /*!< Write protect group enable */

  __IO uint8_t  ManDeflECC;           /*!< Manufacturer default ECC */

  __IO uint8_t  WrSpeedFact;          /*!< Write speed factor */

  __IO uint8_t  MaxWrBlockLen;        /*!< Max. write data block length */

  __IO uint8_t  WriteBlockPaPartial;  /*!< Partial blocks for write allowed */

  __IO uint8_t  Reserved3;            /*!< Reserded */

  __IO uint8_t  ContentProtectAppli;  /*!< Content protection application */

  __IO uint8_t  FileFormatGrouop;     /*!< File format group */

  __IO uint8_t  CopyFlag;             /*!< Copy flag (OTP) */

  __IO uint8_t  PermWrProtect;        /*!< Permanent write protection */

  __IO uint8_t  TempWrProtect;        /*!< Temporary write protection */

  __IO uint8_t  FileFormat;           /*!< File Format */

  __IO uint8_t  ECC;                  /*!< ECC code */

  __IO uint8_t  CSD_CRC;              /*!< CSD CRC */

  __IO uint8_t  Reserved4;            /*!< always 1*/

} SD_CSD;

/** 

  * @brief  Card Identification Data: CID Register   

  */

typedef struct

{

  __IO uint8_t  ManufacturerID;       /*!< ManufacturerID */

  __IO uint16_t OEM_AppliID;          /*!< OEM/Application ID */

  __IO uint32_t ProdName1;            /*!< Product Name part1 */

  __IO uint8_t  ProdName2;            /*!< Product Name part2*/

  __IO uint8_t  ProdRev;              /*!< Product Revision */

  __IO uint32_t ProdSN;               /*!< Product Serial Number */

  __IO uint8_t  Reserved1;            /*!< Reserved1 */

  __IO uint16_t ManufactDate;         /*!< Manufacturing Date */

  __IO uint8_t  CID_CRC;              /*!< CID CRC */

  __IO uint8_t  Reserved2;            /*!< always 1 */

} SD_CID;

/** 

  * @brief SD Card Status 

  */

typedef struct

{

  __IO uint8_t DAT_BUS_WIDTH;

  __IO uint8_t SECURED_MODE;

  __IO uint16_t SD_CARD_TYPE;

  __IO uint32_t SIZE_OF_PROTECTED_AREA;

  __IO uint8_t SPEED_CLASS;

  __IO uint8_t PERFORMANCE_MOVE;

  __IO uint8_t AU_SIZE;

  __IO uint16_t ERASE_SIZE;

  __IO uint8_t ERASE_TIMEOUT;

  __IO uint8_t ERASE_OFFSET;

} SD_CardStatus;

/** 

  * @brief SD Card information 

  */

typedef struct

{

  SD_CSD SD_csd;

  SD_CID SD_cid;

  uint64_t CardCapacity;  /*!< Card Capacity */

  uint32_t CardBlockSize; /*!< Card Block Size */

  uint16_t RCA;

  uint8_t CardType;

} SD_CardInfo;

/****************************************************************************************

* Defines

****************************************************************************************/

/** 

  * @brief SDIO Commands  Index 

  */

#define SD_CMD_GO_IDLE_STATE                       ((uint8_t)0)

#define SD_CMD_SEND_OP_COND                        ((uint8_t)1)

#define SD_CMD_ALL_SEND_CID                        ((uint8_t)2)

#define SD_CMD_SET_REL_ADDR                        ((uint8_t)3) /*!< SDIO_SEND_REL_ADDR for SD Card */

#define SD_CMD_SET_DSR                             ((uint8_t)4)

#define SD_CMD_SDIO_SEN_OP_COND                    ((uint8_t)5)

#define SD_CMD_HS_SWITCH                           ((uint8_t)6)

#define SD_CMD_SEL_DESEL_CARD                      ((uint8_t)7)

#define SD_CMD_HS_SEND_EXT_CSD                     ((uint8_t)8)

#define SD_CMD_SEND_CSD                            ((uint8_t)9)

#define SD_CMD_SEND_CID                            ((uint8_t)10)

#define SD_CMD_READ_DAT_UNTIL_STOP                 ((uint8_t)11) /*!< SD Card doesn't support it */

#define SD_CMD_STOP_TRANSMISSION                   ((uint8_t)12)

#define SD_CMD_SEND_STATUS                         ((uint8_t)13)

#define SD_CMD_HS_BUSTEST_READ                     ((uint8_t)14)

#define SD_CMD_GO_INACTIVE_STATE                   ((uint8_t)15)

#define SD_CMD_SET_BLOCKLEN                        ((uint8_t)16)

#define SD_CMD_READ_SINGLE_BLOCK                   ((uint8_t)17)

#define SD_CMD_READ_MULT_BLOCK                     ((uint8_t)18)

#define SD_CMD_HS_BUSTEST_WRITE                    ((uint8_t)19)

#define SD_CMD_WRITE_DAT_UNTIL_STOP                ((uint8_t)20) /*!< SD Card doesn't support it */

#define SD_CMD_SET_BLOCK_COUNT                     ((uint8_t)23) /*!< SD Card doesn't support it */

#define SD_CMD_WRITE_SINGLE_BLOCK                  ((uint8_t)24)

#define SD_CMD_WRITE_MULT_BLOCK                    ((uint8_t)25)

#define SD_CMD_PROG_CID                            ((uint8_t)26) /*!< reserved for manufacturers */

#define SD_CMD_PROG_CSD                            ((uint8_t)27)

#define SD_CMD_SET_WRITE_PROT                      ((uint8_t)28)

#define SD_CMD_CLR_WRITE_PROT                      ((uint8_t)29)

#define SD_CMD_SEND_WRITE_PROT                     ((uint8_t)30)

#define SD_CMD_SD_ERASE_GRP_START                  ((uint8_t)32) /*!< To set the address of the first write

                                                                  block to be erased. (For SD card only) */

#define SD_CMD_SD_ERASE_GRP_END                    ((uint8_t)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                     ((uint8_t)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                       ((uint8_t)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                               ((uint8_t)38)

#define SD_CMD_FAST_IO                             ((uint8_t)39) /*!< SD Card doesn't support it */

#define SD_CMD_GO_IRQ_STATE                        ((uint8_t)40) /*!< SD Card doesn't support it */

#define SD_CMD_LOCK_UNLOCK                         ((uint8_t)42)

#define SD_CMD_APP_CMD                             ((uint8_t)55)

#define SD_CMD_GEN_CMD                             ((uint8_t)56)

#define SD_CMD_NO_CMD                              ((uint8_t)64)

/** 

  * @brief Following commands are SD Card Specific commands.

  *        SDIO_APP_CMD should be sent before sending these commands. 

  */

#define SD_CMD_APP_SD_SET_BUSWIDTH                 ((uint8_t)6)  /*!< For SD Card only */

#define SD_CMD_SD_APP_STAUS                        ((uint8_t)13) /*!< For SD Card only */

#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS        ((uint8_t)22) /*!< For SD Card only */

#define SD_CMD_SD_APP_OP_COND                      ((uint8_t)41) /*!< For SD Card only */

#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT          ((uint8_t)42) /*!< For SD Card only */

#define SD_CMD_SD_APP_SEND_SCR                     ((uint8_t)51) /*!< For SD Card only */

#define SD_CMD_SDIO_RW_DIRECT                      ((uint8_t)52) /*!< For SD I/O Card only */

#define SD_CMD_SDIO_RW_EXTENDED                    ((uint8_t)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                      ((uint8_t)43) /*!< For SD Card only */

#define SD_CMD_SD_APP_GET_MID                      ((uint8_t)44) /*!< For SD Card only */

#define SD_CMD_SD_APP_SET_CER_RN1                  ((uint8_t)45) /*!< For SD Card only */

#define SD_CMD_SD_APP_GET_CER_RN2                  ((uint8_t)46) /*!< For SD Card only */

#define SD_CMD_SD_APP_SET_CER_RES2                 ((uint8_t)47) /*!< For SD Card only */

#define SD_CMD_SD_APP_GET_CER_RES1                 ((uint8_t)48) /*!< For SD Card only */

#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK   ((uint8_t)18) /*!< For SD Card only */

#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK  ((uint8_t)25) /*!< For SD Card only */

#define SD_CMD_SD_APP_SECURE_ERASE                 ((uint8_t)38) /*!< For SD Card only */

#define SD_CMD_SD_APP_CHANGE_SECURE_AREA           ((uint8_t)49) /*!< For SD Card only */

#define SD_CMD_SD_APP_SECURE_WRITE_MKB             ((uint8_t)48) /*!< For SD Card only */

/* Uncomment the following line to select the SDIO Data transfer mode */  

#define SD_POLLING_MODE                            ((uint32_t)0x00000002)

#if defined (SD_POLLING_MODE)    

  /* do not use DMA mode if configured for polling */

  #if defined (SD_DMA_MODE)    

  #undef SD_DMA_MODE

  #endif

#else

  /* always use DMA mode if configured for interrupt mode */

  #define SD_DMA_MODE                              ((uint32_t)0x00000000)

#endif    

/**

  * @brief  SD detection on its memory slot

  */

#define SD_PRESENT                                 ((uint8_t)0x01)

#define SD_NOT_PRESENT                             ((uint8_t)0x00)

/** 

  * @brief Supported SD Memory Cards 

  */

#define SDIO_STD_CAPACITY_SD_CARD_V1_1             ((uint32_t)0x00000000)

#define SDIO_STD_CAPACITY_SD_CARD_V2_0             ((uint32_t)0x00000001)

#define SDIO_HIGH_CAPACITY_SD_CARD                 ((uint32_t)0x00000002)

#define SDIO_MULTIMEDIA_CARD                       ((uint32_t)0x00000003)

#define SDIO_SECURE_DIGITAL_IO_CARD                ((uint32_t)0x00000004)

#define SDIO_HIGH_SPEED_MULTIMEDIA_CARD            ((uint32_t)0x00000005)

#define SDIO_SECURE_DIGITAL_IO_COMBO_CARD          ((uint32_t)0x00000006)

#define SDIO_HIGH_CAPACITY_MMC_CARD                ((uint32_t)0x00000007)

/** 

  * @brief  SDIO Static flags, TimeOut, FIFO Address  

  */

#ifndef NULL

#define NULL  ((void*)0)

#endif

#define SDIO_STATIC_FLAGS               ((uint32_t)0x000005FF)

#define SDIO_CMD0TIMEOUT                ((uint32_t)0x00010000)

/** 

  * @brief  Mask for errors Card Status R1 (OCR Register) 

  */

#define SD_OCR_ADDR_OUT_OF_RANGE        ((uint32_t)0x80000000)

#define SD_OCR_ADDR_MISALIGNED          ((uint32_t)0x40000000)

#define SD_OCR_BLOCK_LEN_ERR            ((uint32_t)0x20000000)

#define SD_OCR_ERASE_SEQ_ERR            ((uint32_t)0x10000000)

#define SD_OCR_BAD_ERASE_PARAM          ((uint32_t)0x08000000)

#define SD_OCR_WRITE_PROT_VIOLATION     ((uint32_t)0x04000000)

#define SD_OCR_LOCK_UNLOCK_FAILED       ((uint32_t)0x01000000)

#define SD_OCR_COM_CRC_FAILED           ((uint32_t)0x00800000)

#define SD_OCR_ILLEGAL_CMD              ((uint32_t)0x00400000)

#define SD_OCR_CARD_ECC_FAILED          ((uint32_t)0x00200000)

#define SD_OCR_CC_ERROR                 ((uint32_t)0x00100000)

#define SD_OCR_GENERAL_UNKNOWN_ERROR    ((uint32_t)0x00080000)

#define SD_OCR_STREAM_READ_UNDERRUN     ((uint32_t)0x00040000)

#define SD_OCR_STREAM_WRITE_OVERRUN     ((uint32_t)0x00020000)

#define SD_OCR_CID_CSD_OVERWRIETE       ((uint32_t)0x00010000)

#define SD_OCR_WP_ERASE_SKIP            ((uint32_t)0x00008000)

#define SD_OCR_CARD_ECC_DISABLED        ((uint32_t)0x00004000)

#define SD_OCR_ERASE_RESET              ((uint32_t)0x00002000)

#define SD_OCR_AKE_SEQ_ERROR            ((uint32_t)0x00000008)

#define SD_OCR_ERRORBITS                ((uint32_t)0xFDFFE008)

/** 

  * @brief  Masks for R6 Response 

  */

#define SD_R6_GENERAL_UNKNOWN_ERROR     ((uint32_t)0x00002000)

#define SD_R6_ILLEGAL_CMD               ((uint32_t)0x00004000)

#define SD_R6_COM_CRC_FAILED            ((uint32_t)0x00008000)

#define SD_VOLTAGE_WINDOW_SD            ((uint32_t)0x80100000)

#define SD_HIGH_CAPACITY                ((uint32_t)0x40000000)

#define SD_STD_CAPACITY                 ((uint32_t)0x00000000)

#define SD_CHECK_PATTERN                ((uint32_t)0x000001AA)

#define SD_MAX_VOLT_TRIAL               ((uint32_t)0x0000FFFF)

#define SD_ALLZERO                      ((uint32_t)0x00000000)

#define SD_WIDE_BUS_SUPPORT             ((uint32_t)0x00040000)

#define SD_SINGLE_BUS_SUPPORT           ((uint32_t)0x00010000)

#define SD_CARD_LOCKED                  ((uint32_t)0x02000000)

#define SD_DATATIMEOUT                  ((uint32_t)0xFFFFFFFF)

#define SD_0TO7BITS                     ((uint32_t)0x000000FF)

#define SD_8TO15BITS                    ((uint32_t)0x0000FF00)

#define SD_16TO23BITS                   ((uint32_t)0x00FF0000)

#define SD_24TO31BITS                   ((uint32_t)0xFF000000)

#define SD_MAX_DATA_LENGTH              ((uint32_t)0x01FFFFFF)

#define SD_HALFFIFO                     ((uint32_t)0x00000008)

#define SD_HALFFIFOBYTES                ((uint32_t)0x00000020)

/** 

  * @brief  Command Class Supported 

  */

#define SD_CCCC_LOCK_UNLOCK             ((uint32_t)0x00000080)

#define SD_CCCC_WRITE_PROT              ((uint32_t)0x00000040)

#define SD_CCCC_ERASE                   ((uint32_t)0x00000020)

/** 

  * @brief  Following commands are SD Card Specific commands.

  *         SDIO_APP_CMD should be sent before sending these commands. 

  */

#define SDIO_SEND_IF_COND               ((uint32_t)0x00000008)

/**

  * @brief  SD FLASH SDIO Interface

  */

#define SD_DETECT_PIN                    GPIO_Pin_11                 /* PC.11 */

#define SD_DETECT_GPIO_PORT              GPIOC                       /* GPIOC */

#define SD_DETECT_GPIO_CLK               RCC_AHB1Periph_GPIOC

#define SDIO_FIFO_ADDRESS                ((uint32_t)0x40012C80)

/** 

  * @brief  SDIO Intialization Frequency (400KHz max)

  */

#define SDIO_INIT_CLK_DIV                ((uint8_t)0x76)

/** 

  * @brief  SDIO Data Transfer Frequency (25MHz max) 

  */

#define SDIO_TRANSFER_CLK_DIV            ((uint8_t)0x0) 

#define SD_SDIO_DMA                   DMA2

#define SD_SDIO_DMA_CLK               RCC_AHB1Periph_DMA2

#define SD_SDIO_DMA_STREAM            DMA2_Stream3

#define SD_SDIO_DMA_CHANNEL           DMA_Channel_4

#define SD_SDIO_DMA_FLAG_FEIF         DMA_FLAG_FEIF3

#define SD_SDIO_DMA_FLAG_DMEIF        DMA_FLAG_DMEIF3

#define SD_SDIO_DMA_FLAG_TEIF         DMA_FLAG_TEIF3

#define SD_SDIO_DMA_FLAG_HTIF         DMA_FLAG_HTIF3

#define SD_SDIO_DMA_FLAG_TCIF         DMA_FLAG_TCIF3 

#define SD_SDIO_DMA_IRQn              DMA2_Stream3_IRQn

#define SD_SDIO_DMA_IRQHANDLER        DMA2_Stream3_IRQHandler 

#define SD_BLOCKSIZE                   (512)

/****************************************************************************************

* Local data declarations

****************************************************************************************/

static uint32_t CardType =  SDIO_STD_CAPACITY_SD_CARD_V1_1;

static uint32_t CSD_Tab[4], CID_Tab[4], RCA = 0;

static uint8_t SDSTATUS_Tab[64];

static __IO uint32_t StopCondition = 0;

static __IO SD_Error TransferError = SD_OK;

static __IO uint32_t TransferEnd = 0, DMAEndOfTransfer = 1;

static SD_CardInfo SDCardInfo;

static SDIO_InitTypeDef SDIO_InitStructure;

static SDIO_CmdInitTypeDef SDIO_CmdInitStructure;

static SDIO_DataInitTypeDef SDIO_DataInitStructure;

static volatile DSTATUS Stat = STA_NOINIT;    /* Disk status */

/****************************************************************************************

* Function prototypes

****************************************************************************************/

void SD_DeInit(void);

SD_Error SD_Init(void);

SDTransferState SD_GetStatus(void);

SDCardState SD_GetState(void);

uint8_t SD_Detect(void);

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_GetCardStatus(SD_CardStatus *cardstatus);

SD_Error SD_EnableWideBusOperation(uint32_t WideMode);

SD_Error SD_SelectDeselect(uint64_t addr);

SD_Error SD_ReadBlock(uint8_t *readbuff, uint64_t ReadAddr, uint16_t BlockSize);

SD_Error SD_ReadMultiBlocks(uint8_t *readbuff, uint64_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);

SD_Error SD_WriteBlock(uint8_t *writebuff, uint64_t WriteAddr, uint16_t BlockSize);

SD_Error SD_WriteMultiBlocks(uint8_t *writebuff, uint64_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);

SDTransferState SD_GetTransferState(void);

SD_Error SD_StopTransfer(void);

SD_Error SD_Erase(uint64_t startaddr, uint64_t endaddr);

SD_Error SD_SendStatus(uint32_t *pcardstatus);

SD_Error SD_SendSDStatus(uint32_t *psdstatus);

SD_Error SD_ProcessIRQSrc(void);

void SD_ProcessDMAIRQ(void);

SD_Error SD_WaitReadOperation(void);

SD_Error SD_WaitWriteOperation(void);

static SD_Error CmdError(void);

static SD_Error CmdResp1Error(uint8_t cmd);

static SD_Error CmdResp7Error(void);

static SD_Error CmdResp3Error(void);

static SD_Error CmdResp2Error(void);

static SD_Error CmdResp6Error(uint8_t cmd, uint16_t *prca);

static SD_Error SDEnWideBus(FunctionalState NewState);

static SD_Error IsCardProgramming(uint8_t *pstatus);

static SD_Error FindSCR(uint16_t rca, uint32_t *pscr);

static void SD_LowLevel_DeInit(void);

static void SD_LowLevel_Init(void); 

static void SD_LowLevel_DMA_TxConfig(uint32_t *BufferSRC, uint32_t BufferSize);

static void SD_LowLevel_DMA_RxConfig(uint32_t *BufferDST, uint32_t BufferSize);

/**

  * @brief  DeInitializes the SDIO interface.

  * @param  None

  * @retval None

  */

void SD_DeInit(void)

{ 

  SD_LowLevel_DeInit();

}

/**

  * @brief  Initializes the SD Card and put it into StandBy State (Ready for data 

  *         transfer).

  * @param  None

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_Init(void)

{

  __IO SD_Error errorstatus = SD_OK;

  /* SDIO Peripheral Low Level Init */

   SD_LowLevel_Init();

  SDIO_DeInit();

  errorstatus = SD_PowerON();

  if (errorstatus != SD_OK)

  {

    /*!< CMD Response TimeOut (wait for CMDSENT flag) */

    return(errorstatus);

  }

  errorstatus = SD_InitializeCards();

  if (errorstatus != SD_OK)

  {

    /*!< CMD Response TimeOut (wait for CMDSENT flag) */

    return(errorstatus);

  }

  /*!< Configure the SDIO peripheral */

  /*!< SDIO_CK = SDIOCLK / (SDIO_TRANSFER_CLK_DIV + 2) */

  /*!< on STM32F4xx devices, SDIOCLK is fixed to 48MHz */

  SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV;

  SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;

  SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;

  SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;

  SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;

  SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;

  SDIO_Init(&SDIO_InitStructure);

  /*----------------- Read CSD/CID MSD registers ------------------*/

  errorstatus = SD_GetCardInfo(&SDCardInfo);

  if (errorstatus == SD_OK)

  {

    /*----------------- Select Card --------------------------------*/

    errorstatus = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));

  }

  if (errorstatus == SD_OK)

  {

    errorstatus = SD_EnableWideBusOperation(SDIO_BusWide_4b);

  }  

  return(errorstatus);

}

/**

  * @brief  Gets the cuurent sd card data transfer status.

  * @param  None

  * @retval SDTransferState: Data Transfer state.

  *   This value can be: 

  *        - SD_TRANSFER_OK: No data transfer is acting

  *        - SD_TRANSFER_BUSY: Data transfer is acting

  */

SDTransferState SD_GetStatus(void)

{

  SDCardState cardstate =  SD_CARD_TRANSFER;

  cardstate = SD_GetState();

  if (cardstate == SD_CARD_TRANSFER)

  {

    return(SD_TRANSFER_OK);

  }

  else if(cardstate == SD_CARD_ERROR)

  {

    return (SD_TRANSFER_ERROR);

  }

  else

  {

    return(SD_TRANSFER_BUSY);

  }

}

/**

  * @brief  Returns the current card's state.

  * @param  None

  * @retval SDCardState: SD Card Error or SD Card Current State.

  */

SDCardState SD_GetState(void)

{

  uint32_t resp1 = 0;

  if(SD_Detect()== SD_PRESENT)

  {

    if (SD_SendStatus(&resp1) != SD_OK)

    {

      return SD_CARD_ERROR;

    }

    else

    {

      return (SDCardState)((resp1 >> 9) & 0x0F);

    }

  }

  else

  {

    return SD_CARD_ERROR;

  }

}

/**

 * @brief  Detect if SD card is correctly plugged in the memory slot.

 * @param  None

 * @retval Return if SD is detected or not

 */

uint8_t SD_Detect(void)

{

  __IO uint8_t status = SD_PRESENT;

  /*!< Check GPIO to detect SD */

        if (GPIO_ReadInputDataBit(SD_DETECT_GPIO_PORT, SD_DETECT_PIN) == Bit_RESET)

  {

    status = SD_NOT_PRESENT;

  }

  return status;

}

/**

  * @brief  Enquires cards about their operating voltage and configures 

  *   clock controls.

  * @param  None

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_PowerON(void)

{

  __IO SD_Error errorstatus = SD_OK;

  uint32_t response = 0, count = 0, validvoltage = 0;

  uint32_t SDType = SD_STD_CAPACITY;

  /*!< Power ON Sequence -----------------------------------------------------*/

  /*!< Configure the SDIO peripheral */

  /*!< SDIO_CK = SDIOCLK / (SDIO_INIT_CLK_DIV + 2) */

  /*!< on STM32F4xx devices, SDIOCLK is fixed to 48MHz */

  /*!< SDIO_CK for initialization should not exceed 400 KHz */  

  SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV;

  SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;

  SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;

  SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;

  SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;

  SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;

  SDIO_Init(&SDIO_InitStructure);

  /*!< Set Power State to ON */

  SDIO_SetPowerState(SDIO_PowerState_ON);

  /*!< Enable SDIO Clock */

  SDIO_ClockCmd(ENABLE);

  /*!< CMD0: GO_IDLE_STATE ---------------------------------------------------*/

  /*!< No CMD response required */

  SDIO_CmdInitStructure.SDIO_Argument = 0x0;

  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE;

  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No;

  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;

  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;

  SDIO_SendCommand(&SDIO_CmdInitStructure);

  errorstatus = CmdError();

  if (errorstatus != SD_OK)

  {

    /*!< CMD Response TimeOut (wait for CMDSENT flag) */

    return(errorstatus);

  }

  /*!< CMD8: SEND_IF_COND ----------------------------------------------------*/

  /*!< Send CMD8 to verify SD card interface operating condition */

  /*!< Argument: - [31:12]: Reserved (shall be set to '0')

               - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)

               - [7:0]: Check Pattern (recommended 0xAA) */

  /*!< CMD Response: R7 */

  SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN;

  SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND;

  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 = CmdResp7Error();

  if (errorstatus == SD_OK)

  {

    CardType = SDIO_STD_CAPACITY_SD_CARD_V2_0; /*!< SD Card 2.0 */

    SDType = SD_HIGH_CAPACITY;

  }

  else

  {

    /*!< CMD55 */

    SDIO_CmdInitStructure.SDIO_Argument = 0x00;

    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);

  }

  /*!< CMD55 */

  SDIO_CmdInitStructure.SDIO_Argument = 0x00;

  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 is Command TimeOut, it is a MMC card */

  /*!< If errorstatus is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)

     or SD card 1.x */

  if (errorstatus == SD_OK)

  {

    /*!< SD CARD */

    /*!< Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */

    while ((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))

    {

      /*!< SEND CMD55 APP_CMD with RCA as 0 */

      SDIO_CmdInitStructure.SDIO_Argument = 0x00;

      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 = SD_VOLTAGE_WINDOW_SD | SDType;

      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND;

      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 = CmdResp3Error();

      if (errorstatus != SD_OK)

      {

        return(errorstatus);

      }

      response = SDIO_GetResponse(SDIO_RESP1);

      validvoltage = (((response >> 31) == 1) ? 1 : 0);

      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 Card */

  return(errorstatus);

}

/**

  * @brief  Turns the SDIO output signals off.

  * @param  None

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_PowerOFF(void)

{

  SD_Error errorstatus = SD_OK;

  /*!< Set Power State to OFF */

  SDIO_SetPowerState(SDIO_PowerState_OFF);

  return(errorstatus);

}

/**

  * @brief  Intialises all cards or single card as the case may be Card(s) come 

  *         into standby state.

  * @param  None

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_InitializeCards(void)

{

  SD_Error errorstatus = SD_OK;

  uint16_t rca = 0x01;

  if (SDIO_GetPowerState() == SDIO_PowerState_OFF)

  {

    errorstatus = SD_REQUEST_NOT_APPLICABLE;

    return(errorstatus);

  }

  if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)

  {

    /*!< Send CMD2 ALL_SEND_CID */

    SDIO_CmdInitStructure.SDIO_Argument = 0x0;

    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);

    errorstatus = CmdResp2Error();

    if (SD_OK != errorstatus)

    {

      return(errorstatus);

    }

    CID_Tab[0] = SDIO_GetResponse(SDIO_RESP1);

    CID_Tab[1] = SDIO_GetResponse(SDIO_RESP2);

    CID_Tab[2] = SDIO_GetResponse(SDIO_RESP3);

    CID_Tab[3] = SDIO_GetResponse(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))

  {

    /*!< Send CMD3 SET_REL_ADDR with argument 0 */

    /*!< SD Card publishes its RCA. */

    SDIO_CmdInitStructure.SDIO_Argument = 0x00;

    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR;

    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 = CmdResp6Error(SD_CMD_SET_REL_ADDR, &rca);

    if (SD_OK != errorstatus)

    {

      return(errorstatus);

    }

  }

  if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)

  {

    RCA = rca;

    /*!< Send CMD9 SEND_CSD with argument as card's RCA */

    SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);

    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();

    if (SD_OK != errorstatus)

    {

      return(errorstatus);

    }

    CSD_Tab[0] = SDIO_GetResponse(SDIO_RESP1);

    CSD_Tab[1] = SDIO_GetResponse(SDIO_RESP2);

    CSD_Tab[2] = SDIO_GetResponse(SDIO_RESP3);

    CSD_Tab[3] = SDIO_GetResponse(SDIO_RESP4);

  }

  errorstatus = SD_OK; /*!< All cards get intialized */

  return(errorstatus);

}

/**

  * @brief  Returns information about specific card.

  * @param  cardinfo: pointer to a SD_CardInfo structure that contains all SD card 

  *         information.

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)

{

  SD_Error errorstatus = SD_OK;

  uint8_t tmp = 0;

  cardinfo->CardType = (uint8_t)CardType;

  cardinfo->RCA = (uint16_t)RCA;

  /*!< Byte 0 */

  tmp = (uint8_t)((CSD_Tab[0] & 0xFF000000) >> 24);

  cardinfo->SD_csd.CSDStruct = (tmp & 0xC0) >> 6;

  cardinfo->SD_csd.SysSpecVersion = (tmp & 0x3C) >> 2;

  cardinfo->SD_csd.Reserved1 = tmp & 0x03;

  /*!< Byte 1 */

  tmp = (uint8_t)((CSD_Tab[0] & 0x00FF0000) >> 16);

  cardinfo->SD_csd.TAAC = tmp;

  /*!< Byte 2 */

  tmp = (uint8_t)((CSD_Tab[0] & 0x0000FF00) >> 8);

  cardinfo->SD_csd.NSAC = tmp;

  /*!< Byte 3 */

  tmp = (uint8_t)(CSD_Tab[0] & 0x000000FF);

  cardinfo->SD_csd.MaxBusClkFrec = tmp;

  /*!< Byte 4 */

  tmp = (uint8_t)((CSD_Tab[1] & 0xFF000000) >> 24);

  cardinfo->SD_csd.CardComdClasses = tmp << 4;

  /*!< Byte 5 */

  tmp = (uint8_t)((CSD_Tab[1] & 0x00FF0000) >> 16);

  cardinfo->SD_csd.CardComdClasses |= (tmp & 0xF0) >> 4;

  cardinfo->SD_csd.RdBlockLen = tmp & 0x0F;

  /*!< Byte 6 */

  tmp = (uint8_t)((CSD_Tab[1] & 0x0000FF00) >> 8);

  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; /*!< Reserved */

  if ((CardType == SDIO_STD_CAPACITY_SD_CARD_V1_1) || (CardType == SDIO_STD_CAPACITY_SD_CARD_V2_0))

  {

    cardinfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;

    /*!< Byte 7 */

    tmp = (uint8_t)(CSD_Tab[1] & 0x000000FF);

    cardinfo->SD_csd.DeviceSize |= (tmp) << 2;

    /*!< Byte 8 */

    tmp = (uint8_t)((CSD_Tab[2] & 0xFF000000) >> 24);

    cardinfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;

    cardinfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;

    cardinfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);

    /*!< Byte 9 */

    tmp = (uint8_t)((CSD_Tab[2] & 0x00FF0000) >> 16);

    cardinfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;

    cardinfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;

    cardinfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;

    /*!< Byte 10 */

    tmp = (uint8_t)((CSD_Tab[2] & 0x0000FF00) >> 8);

    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)

  {

    /*!< Byte 7 */

    tmp = (uint8_t)(CSD_Tab[1] & 0x000000FF);

    cardinfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;

    /*!< Byte 8 */

    tmp = (uint8_t)((CSD_Tab[2] & 0xFF000000) >> 24);

    cardinfo->SD_csd.DeviceSize |= (tmp << 8);

    /*!< Byte 9 */

    tmp = (uint8_t)((CSD_Tab[2] & 0x00FF0000) >> 16);

    cardinfo->SD_csd.DeviceSize |= (tmp);

    /*!< Byte 10 */

    tmp = (uint8_t)((CSD_Tab[2] & 0x0000FF00) >> 8);

    cardinfo->CardCapacity = ((uint64_t)cardinfo->SD_csd.DeviceSize + 1) * 512 * 1024;

    cardinfo->CardBlockSize = 512;    

  }

  cardinfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;

  cardinfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;

  /*!< Byte 11 */

  tmp = (uint8_t)(CSD_Tab[2] & 0x000000FF);

  cardinfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;

  cardinfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);

  /*!< Byte 12 */

  tmp = (uint8_t)((CSD_Tab[3] & 0xFF000000) >> 24);

  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;

  /*!< Byte 13 */

  tmp = (uint8_t)((CSD_Tab[3] & 0x00FF0000) >> 16);

  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);

  /*!< Byte 14 */

  tmp = (uint8_t)((CSD_Tab[3] & 0x0000FF00) >> 8);

  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);

  /*!< Byte 15 */

  tmp = (uint8_t)(CSD_Tab[3] & 0x000000FF);

  cardinfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;

  cardinfo->SD_csd.Reserved4 = 1;

  /*!< Byte 0 */

  tmp = (uint8_t)((CID_Tab[0] & 0xFF000000) >> 24);

  cardinfo->SD_cid.ManufacturerID = tmp;

  /*!< Byte 1 */

  tmp = (uint8_t)((CID_Tab[0] & 0x00FF0000) >> 16);

  cardinfo->SD_cid.OEM_AppliID = tmp << 8;

  /*!< Byte 2 */

  tmp = (uint8_t)((CID_Tab[0] & 0x000000FF00) >> 8);

  cardinfo->SD_cid.OEM_AppliID |= tmp;

  /*!< Byte 3 */

  tmp = (uint8_t)(CID_Tab[0] & 0x000000FF);

  cardinfo->SD_cid.ProdName1 = tmp << 24;

  /*!< Byte 4 */

  tmp = (uint8_t)((CID_Tab[1] & 0xFF000000) >> 24);

  cardinfo->SD_cid.ProdName1 |= tmp << 16;

  /*!< Byte 5 */

  tmp = (uint8_t)((CID_Tab[1] & 0x00FF0000) >> 16);

  cardinfo->SD_cid.ProdName1 |= tmp << 8;

  /*!< Byte 6 */

  tmp = (uint8_t)((CID_Tab[1] & 0x0000FF00) >> 8);

  cardinfo->SD_cid.ProdName1 |= tmp;

  /*!< Byte 7 */

  tmp = (uint8_t)(CID_Tab[1] & 0x000000FF);

  cardinfo->SD_cid.ProdName2 = tmp;

  /*!< Byte 8 */

  tmp = (uint8_t)((CID_Tab[2] & 0xFF000000) >> 24);

  cardinfo->SD_cid.ProdRev = tmp;

  /*!< Byte 9 */

  tmp = (uint8_t)((CID_Tab[2] & 0x00FF0000) >> 16);

  cardinfo->SD_cid.ProdSN = tmp << 24;

  /*!< Byte 10 */

  tmp = (uint8_t)((CID_Tab[2] & 0x0000FF00) >> 8);

  cardinfo->SD_cid.ProdSN |= tmp << 16;

  /*!< Byte 11 */

  tmp = (uint8_t)(CID_Tab[2] & 0x000000FF);

  cardinfo->SD_cid.ProdSN |= tmp << 8;

  /*!< Byte 12 */

  tmp = (uint8_t)((CID_Tab[3] & 0xFF000000) >> 24);

  cardinfo->SD_cid.ProdSN |= tmp;

  /*!< Byte 13 */

  tmp = (uint8_t)((CID_Tab[3] & 0x00FF0000) >> 16);

  cardinfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;

  cardinfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;

  /*!< Byte 14 */

  tmp = (uint8_t)((CID_Tab[3] & 0x0000FF00) >> 8);

  cardinfo->SD_cid.ManufactDate |= tmp;

  /*!< Byte 15 */

  tmp = (uint8_t)(CID_Tab[3] & 0x000000FF);

  cardinfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;

  cardinfo->SD_cid.Reserved2 = 1;

  return(errorstatus);

}

/**

  * @brief  Enables wide bus opeartion for the requeseted card if supported by 

  *         card.

  * @param  WideMode: Specifies the SD card wide bus mode. 

  *   This parameter can be one of the following values:

  *     @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

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_GetCardStatus(SD_CardStatus *cardstatus)

{

  SD_Error errorstatus = SD_OK;

  uint8_t tmp = 0;

  errorstatus = SD_SendSDStatus((uint32_t *)SDSTATUS_Tab);

  if (errorstatus  != SD_OK)

  {

    return(errorstatus);

  }

  /*!< Byte 0 */

  tmp = (uint8_t)((SDSTATUS_Tab[0] & 0xC0) >> 6);

  cardstatus->DAT_BUS_WIDTH = tmp;

  /*!< Byte 0 */

  tmp = (uint8_t)((SDSTATUS_Tab[0] & 0x20) >> 5);

  cardstatus->SECURED_MODE = tmp;

  /*!< Byte 2 */

  tmp = (uint8_t)((SDSTATUS_Tab[2] & 0xFF));

  cardstatus->SD_CARD_TYPE = tmp << 8;

  /*!< Byte 3 */

  tmp = (uint8_t)((SDSTATUS_Tab[3] & 0xFF));

  cardstatus->SD_CARD_TYPE |= tmp;

  /*!< Byte 4 */

  tmp = (uint8_t)(SDSTATUS_Tab[4] & 0xFF);

  cardstatus->SIZE_OF_PROTECTED_AREA = tmp << 24;

  /*!< Byte 5 */

  tmp = (uint8_t)(SDSTATUS_Tab[5] & 0xFF);

  cardstatus->SIZE_OF_PROTECTED_AREA |= tmp << 16;

  /*!< Byte 6 */

  tmp = (uint8_t)(SDSTATUS_Tab[6] & 0xFF);

  cardstatus->SIZE_OF_PROTECTED_AREA |= tmp << 8;

  /*!< Byte 7 */

  tmp = (uint8_t)(SDSTATUS_Tab[7] & 0xFF);

  cardstatus->SIZE_OF_PROTECTED_AREA |= tmp;

  /*!< Byte 8 */

  tmp = (uint8_t)((SDSTATUS_Tab[8] & 0xFF));

  cardstatus->SPEED_CLASS = tmp;

  /*!< Byte 9 */

  tmp = (uint8_t)((SDSTATUS_Tab[9] & 0xFF));

  cardstatus->PERFORMANCE_MOVE = tmp;

  /*!< Byte 10 */

  tmp = (uint8_t)((SDSTATUS_Tab[10] & 0xF0) >> 4);

  cardstatus->AU_SIZE = tmp;

  /*!< Byte 11 */

  tmp = (uint8_t)(SDSTATUS_Tab[11] & 0xFF);

  cardstatus->ERASE_SIZE = tmp << 8;

  /*!< Byte 12 */

  tmp = (uint8_t)(SDSTATUS_Tab[12] & 0xFF);

  cardstatus->ERASE_SIZE |= tmp;

  /*!< Byte 13 */

  tmp = (uint8_t)((SDSTATUS_Tab[13] & 0xFC) >> 2);

  cardstatus->ERASE_TIMEOUT = tmp;

  /*!< Byte 13 */

  tmp = (uint8_t)((SDSTATUS_Tab[13] & 0x3));

  cardstatus->ERASE_OFFSET = tmp;

  return(errorstatus);

}

/**

  * @brief  Enables wide bus opeartion for the requeseted card if supported by 

  *         card.

  * @param  WideMode: Specifies the SD card wide bus mode. 

  *   This parameter can be one of the following values:

  *     @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

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_EnableWideBusOperation(uint32_t WideMode)

{

  SD_Error errorstatus = SD_OK;

  /*!< MMC Card doesn't support this feature */

  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)

    {

      errorstatus = SD_UNSUPPORTED_FEATURE;

      return(errorstatus);

    }

    else if (SDIO_BusWide_4b == WideMode)

    {

      errorstatus = SDEnWideBus(ENABLE);

      if (SD_OK == errorstatus)

      {

        /*!< Configure the SDIO peripheral */

        SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV; 

        SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;

        SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;

        SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;

        SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_4b;

        SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;

        SDIO_Init(&SDIO_InitStructure);

      }

    }

    else

    {

      errorstatus = SDEnWideBus(DISABLE);

      if (SD_OK == errorstatus)

      {

        /*!< Configure the SDIO peripheral */

        SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV; 

        SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;

        SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;

        SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;

        SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;

        SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;

        SDIO_Init(&SDIO_InitStructure);

      }

    }

  }

  return(errorstatus);

}

/**

  * @brief  Selects od Deselects the corresponding card.

  * @param  addr: Address of the Card to be selected.

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_SelectDeselect(uint64_t addr)

{

  SD_Error errorstatus = SD_OK;

  /*!< Send CMD7 SDIO_SEL_DESEL_CARD */

  SDIO_CmdInitStructure.SDIO_Argument =  (uint32_t)addr;

  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);

  errorstatus = CmdResp1Error(SD_CMD_SEL_DESEL_CARD);

  return(errorstatus);

}

/**

  * @brief  Allows to read one block from a specified address in a card. The Data

  *         transfer can be managed by DMA mode or Polling mode. 

  * @note   This operation should be followed by two functions to check if the 

  *         DMA Controller and SD Card status.

  *          - SD_ReadWaitOperation(): this function insure that the DMA

  *            controller has finished all data transfer.

  *          - SD_GetStatus(): to check that the SD Card has finished the 

  *            data transfer and it is ready for data.            

  * @param  readbuff: pointer to the buffer that will contain the received data

  * @param  ReadAddr: Address from where data are to be read.  

  * @param  BlockSize: the SD card Data block size. The Block size should be 512.

  * @retval SD_Error: SD Card Error code.

  */

SD_Error SD_ReadBlock(uint8_t *readbuff, uint64_t ReadAddr, uint16_t BlockSize)

{

  SD_Error errorstatus = SD_OK;

#if defined (SD_POLLING_MODE) 

  uint32_t count = 0, *tempbuff = (uint32_t *)readbuff;

#endif

  TransferError = SD_OK;

  TransferEnd = 0;

  StopCondition = 0;

  SDIO->DCTRL = 0x0;

#if defined (SD_DMA_MODE)

  SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_STBITERR, ENABLE);

  SDIO_DMACmd(ENABLE);

  SD_LowLevel_DMA_RxConfig((uint32_t *)readbuff, BlockSize);

#endif

  if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)

  {

    BlockSize = 512;

    ReadAddr /= 512;

  }

  /* Set Block Size for Card */ 

  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;

  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);

        uint32_t timeout = SDIO_CMD0TIMEOUT; /*!< 10000 */

        while ((timeout > 0) && (SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) == RESET))

        {

                timeout--;

        }

  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCKLEN);

  if (SD_OK != errorstatus)

  {

    return(errorstatus);

  }

  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;

  SDIO_DataInitStructure.SDIO_DataLength = BlockSize;

  SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) 9 << 4;

  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);

  /*!< Send CMD17 READ_SINGLE_BLOCK */

  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)ReadAddr;

  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);

  errorstatus = CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);

  if (errorstatus != SD_OK)

  {

    return(errorstatus);

  }

#if defined (SD_POLLING_MODE)  

  /*!< In case of single block transfer, no need of stop transfer at all.*/

  /*!< Polling mode */

  while (!(SDIO->STA &(SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR)))

  {

    if (SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)

    {

      for (count = 0; count < 8; count++)