stm32 sdio sdcard fatfs

/****************************************Copyright (c)****************************************************
 **
 **                                 http://www.powermcu.com
 **
 **--------------File Info---------------------------------------------------------------------------------
 ** File name:               diskio.c
 ** Descriptions:            The FATFS Diskio
 **
 **--------------------------------------------------------------------------------------------------------
 ** Created by:              AVRman
 ** Created date:            2010-11-4
 ** Version:                 v1.0
 ** Descriptions:            The original version
 **
 **--------------------------------------------------------------------------------------------------------
 ** Modified by:
 ** Modified date:
 ** Version:
 ** Descriptions:
 **
 *********************************************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "diskio.h"
#include "sdio_sd.h"

/* Private variables ---------------------------------------------------------*/
extern SD_CardInfo SDCardInfo;

DSTATUS disk_initialize ( BYTE drv /* Physical drive nmuber (0..) */ )
{
  SD_Error Status;

  switch ( drv )
  {
  case 0:
    Status = SD_Init ( ); ;
    if ( Status == SD_OK )
    {
      return 0;
    }
    else
    {
      return STA_NOINIT;
    }

  case 1:
    return STA_NOINIT;

  case 2:
    return STA_NOINIT;
  }
  return STA_NOINIT;
}

/*-----------------------------------------------------------------------*/
/* Return Disk Status                                                    */

DSTATUS disk_status ( BYTE drv /* Physical drive nmuber (0..) */ )
{
  switch ( drv )
  {
  case 0:

    /* translate the reslut code here    */

    return 0;

  case 1:

    /* translate the reslut code here    */

    return 0;

  case 2:

    /* translate the reslut code here    */

    return 0;

  default:

    break;
  }
  return STA_NOINIT;
}

/*-----------------------------------------------------------------------*/
/* Read Sector(s)                                                        */

DRESULT disk_read ( BYTE drv, /* Physical drive nmuber (0..) */ BYTE * buff,
  /* Data buffer to store read data */ DWORD sector,
  /* Sector address (LBA) */ BYTE count
  /* Number of sectors to read (1..255) */ )
{
  SD_Error Status;
  if ( !count )
  {
    return RES_PARERR; /* count不能等于0，否则返回参数错误 */
  }

  switch ( drv )
  {

  case 0:
    if ( count == 1 ) /* 1个sector的读操作 */
    {
      Status = SD_ReadBlock ( buff, sector << 9, SDCardInfo.CardBlockSize );
    }
    else /* 多个sector的读操作 */
    {
      Status = SD_ReadMultiBlocks ( buff, sector << 9, SDCardInfo.CardBlockSize,
        count );
    }
    if ( Status == SD_OK )
    {
      return RES_OK;
    }
    else
    {
      return RES_ERROR;
    }

  case 1:
    break;

  case 2:
    break;

  default:
    break;

  }

  return RES_ERROR;
}

/*-----------------------------------------------------------------------*/
/* Write Sector(s)                                                       */

#if _READONLY == 0

DRESULT disk_write ( BYTE drv,
  /* Physical drive nmuber (0..) */ const BYTE * buff,
  /* Data to be written */ DWORD sector,
  /* Sector address (LBA) */ BYTE count
  /* Number of sectors to write (1..255) */ )
{
  SD_Error Status;
  if ( !count )
  {
    return RES_PARERR; /* count不能等于0，否则返回参数错误 */
  }

  switch ( drv )
  {
  case 0:
    if ( count == 1 ) /* 1个sector的写操作 */
    {
      Status = SD_WriteBlock ( ( uint8_t* )( &buff[ 0 ] ), sector << 9,
        SDCardInfo.CardBlockSize );
    }
    else /* 多个sector的写操作 */
    {
      Status = SD_WriteMultiBlocks ( ( uint8_t* )( &buff[ 0 ] ), sector << 9,
        SDCardInfo.CardBlockSize, count );
    }
    if ( Status == SD_OK )
    {
      return RES_OK;
    }
    else
    {
      return RES_ERROR;
    }
  case 2:
    break;
  default:
    break;
  }
  return RES_ERROR;
}
#endif /* _READONLY */

/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions                                               */

DRESULT disk_ioctl ( BYTE drv, /* Physical drive nmuber (0..) */ BYTE ctrl,
  /* Control code */ void * buff /* Buffer to send/receive control data */ )
{
  if ( drv )
  {
    return RES_PARERR; /* 仅支持单磁盘操作，否则返回参数错误 */
  }
  switch ( ctrl )
  {
  case CTRL_SYNC:

    return RES_OK;

  case GET_SECTOR_COUNT:
    *( DWORD* )buff = SDCardInfo.CardCapacity / SDCardInfo.CardBlockSize;
    return RES_OK;

  case GET_BLOCK_SIZE:
    *( WORD* )buff = SDCardInfo.CardBlockSize;
    return RES_OK;

  case CTRL_POWER:
    break;

  case CTRL_LOCK:
    break;

  case CTRL_EJECT:
    break;

    /* MMC/SDC command */
  case MMC_GET_TYPE:
    break;

  case MMC_GET_CSD:
    break;

  case MMC_GET_CID:
    break;

  case MMC_GET_OCR:
    break;

  case MMC_GET_SDSTAT:
    break;
  }
  return RES_PARERR;
}

/* 得到文件Calendar格式的建立日期,是DWORD get_fattime (void) 逆变换 */
/*-----------------------------------------------------------------------*/
/* User defined function to give a current time to fatfs module          */
/* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */
/* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
DWORD get_fattime ( void )
{

  return 0;
}

/*********************************************************************************************************
 END FILE
 *********************************************************************************************************/

/****************************************Copyright (c)****************************************************
 **
 **                                 http://www.powermcu.com
 **
 **--------------File Info---------------------------------------------------------------------------------
 ** File name:               sdio_sd.h
 ** Descriptions:            sdio sd卡操作函数
 **
 **--------------------------------------------------------------------------------------------------------
 ** Created by:              AVRman
 ** Created date:            2010-10-30
 ** Version:                 v1.0
 ** Descriptions:            The original version
 **
 **--------------------------------------------------------------------------------------------------------
 ** Modified by:
 ** Modified date:
 ** Version:
 ** Descriptions:
 **
 *********************************************************************************************************/

/******************************************************************************
 *          +-----------------------------------------------------------+
 *          |                     Pin assignment                        |
 *          +-----------------------------+---------------+-------------+
 *          |  STM32 SDIO Pins            |     SD        |    Pin      |
 *          +-----------------------------+---------------+-------------+
 *          |      SDIO D2                |   D2          |    1        |
 *          |      SDIO D3                |   D3          |    2        |
 *          |      SDIO CMD               |   CMD         |    3        |
 *          |                             |   VCC         |    4 (3.3 V)|
 *          |      SDIO CK               |    CLK         |    5        |
 *          |                             |   GND         |    6 (0 V)  |
 *          |      SDIO D0                |   D0          |    7        |
 *          |      SDIO D1                |   D1          |    8        |
 *          +-----------------------------+---------------+-------------+
 *****************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "sdio_sd.h"

/**
 * @brief  SDIO Static flags, TimeOut, FIFO Address
 */
#define NULL 0
#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)0x000FFFFF)
#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)

/**
 * @}
 */

/** @defgroup STM32_EVAL_SDIO_SD_Private_Macros
 * @{
 */
/**
 * @}
 */

/** @defgroup STM32_EVAL_SDIO_SD_Private_Variables
 * @{
 */
static uint32_t CardType = SDIO_STD_CAPACITY_SD_CARD_V1_1;
static uint32_t CSD_Tab[ 4 ], CID_Tab[ 4 ], RCA = 0;
static uint32_t DeviceMode         = SD_POLLING_MODE;
static uint32_t TotalNumberOfBytes = 0, StopCondition = 0;
uint32_t * SrcBuffer, *DestBuffer;
__IO SD_Error TransferError = SD_OK;
__IO uint32_t TransferEnd   = 0;
__IO uint32_t NumberOfBytes = 0;
SD_CardInfo SDCardInfo;
SDIO_InitTypeDef SDIO_InitStructure;
SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
SDIO_DataInitTypeDef SDIO_DataInitStructure;
/**
 * @}
 */

/** @defgroup STM32_EVAL_SDIO_SD_Private_Function_Prototypes
 * @{
 */
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 uint8_t convert_from_bytes_to_power_of_two ( uint16_t NumberOfBytes );

/**
 * @}
 */

/** @defgroup STM32_EVAL_SDIO_SD_Private_Functions
 * @{
 */

/**
 * @brief  DeInitializes the SDIO interface.
 * @param  None
 * @retval None
 */
void SD_DeInit ( void )
{

}

/**
 * @brief  Initializes the SD Card and put it into StandBy State (Ready for
 *         data transfer).
 * @param  None
 * @retval None
 */
void SD_LowLevel_Init ( void )
{
  GPIO_InitTypeDef GPIO_InitStructure;

  /*!< GPIOC and GPIOD Periph clock enable */
  RCC_APB2PeriphClockCmd ( RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD |
    SD_DETECT_GPIO_CLK, ENABLE );

  /*!< Configure PC.08, PC.09, PC.10, PC.11, PC.12 pin: D0, D1, D2, D3, CLK pin */
  GPIO_InitStructure.GPIO_Pin =
    GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
  GPIO_Init ( GPIOC, & GPIO_InitStructure );

  /*!< Configure PD.02 CMD line */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_Init ( GPIOD, & GPIO_InitStructure );

  /*!< Configure SD_CD pin: SD Card detect pin */
  GPIO_InitStructure.GPIO_Pin  = SD_DETECT_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  GPIO_Init ( SD_DETECT_GPIO_PORT, & GPIO_InitStructure );

  /*!< Enable the SDIO AHB Clock */
  RCC_AHBPeriphClockCmd ( RCC_AHBPeriph_SDIO, ENABLE );

  /*!< Enable the DMA2 Clock */
  RCC_AHBPeriphClockCmd ( RCC_AHBPeriph_DMA2, ENABLE );
}

uint32_t SD_DMAEndOfTransferStatus ( void )
{
  return ( uint32_t )DMA_GetFlagStatus ( DMA2_FLAG_TC4 );
}

/**
 * @brief  Configures the DMA2 Channel4 for SDIO Rx request.
 * @param  BufferDST: pointer to the destination buffer
 * @param  BufferSize: buffer size
 * @retval None
 */
void SD_LowLevel_DMA_RxConfig ( uint32_t * BufferDST, uint32_t BufferSize )
{
  DMA_InitTypeDef DMA_InitStructure;

  DMA_ClearFlag ( DMA2_FLAG_TC4 | DMA2_FLAG_TE4 | DMA2_FLAG_HT4 |
    DMA2_FLAG_GL4 );

  /*!< DMA2 Channel4 disable */
  DMA_Cmd ( DMA2_Channel4, DISABLE );

  /*!< DMA2 Channel4 Config */
  DMA_InitStructure.DMA_PeripheralBaseAddr = ( uint32_t )SDIO_FIFO_ADDRESS;
  DMA_InitStructure.DMA_MemoryBaseAddr     = ( uint32_t )BufferDST;
  DMA_InitStructure.DMA_DIR                = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize         = BufferSize / 4;
  DMA_InitStructure.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc          = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
  DMA_InitStructure.DMA_MemoryDataSize     = DMA_MemoryDataSize_Word;
  DMA_InitStructure.DMA_Mode               = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority           = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M                = DMA_M2M_Disable;
  DMA_Init ( DMA2_Channel4, & DMA_InitStructure );

  /*!< DMA2 Channel4 enable */
  DMA_Cmd ( DMA2_Channel4, ENABLE );
}

/**
 * @brief  Configures the DMA2 Channel4 for SDIO Tx request.
 * @param  BufferSRC: pointer to the source buffer
 * @param  BufferSize: buffer size
 * @retval None
 */
void SD_LowLevel_DMA_TxConfig ( uint32_t * BufferSRC, uint32_t BufferSize )
{

  DMA_InitTypeDef DMA_InitStructure;

  DMA_ClearFlag ( DMA2_FLAG_TC4 | DMA2_FLAG_TE4 | DMA2_FLAG_HT4 |
    DMA2_FLAG_GL4 );

  /*!< DMA2 Channel4 disable */
  DMA_Cmd ( DMA2_Channel4, DISABLE );

  /*!< DMA2 Channel4 Config */
  DMA_InitStructure.DMA_PeripheralBaseAddr = ( uint32_t )SDIO_FIFO_ADDRESS;
  DMA_InitStructure.DMA_MemoryBaseAddr     = ( uint32_t )BufferSRC;
  DMA_InitStructure.DMA_DIR                = DMA_DIR_PeripheralDST;
  DMA_InitStructure.DMA_BufferSize         = BufferSize / 4;
  DMA_InitStructure.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc          = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
  DMA_InitStructure.DMA_MemoryDataSize     = DMA_MemoryDataSize_Word;
  DMA_InitStructure.DMA_Mode               = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority           = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M                = DMA_M2M_Disable;
  DMA_Init ( DMA2_Channel4, & DMA_InitStructure );

  /*!< DMA2 Channel4 enable */
  DMA_Cmd ( DMA2_Channel4, ENABLE );
}

/**
 * @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 )
{
  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 */
  /*!< SDIOCLK = HCLK, SDIO_CK = HCLK/(2 + SDIO_TRANSFER_CLK_DIV) */
  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 );

  if ( errorstatus == SD_OK )
  {
    /*----------------- 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 );
  }

  /* Set Device Transfer Mode to DMA */
  if ( errorstatus == SD_OK )
  {
    errorstatus = SD_SetDeviceMode ( SD_DMA_MODE );
  }

  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 )
{
  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 */
  /*!< SDIOCLK = HCLK, SDIO_CK = HCLK/(2 + SDIO_INIT_CLK_DIV) */
  /*!< 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  = ( 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_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  Sets device mode whether to operate in Polling, Interrupt or DMA mode.
 * @param  Mode: Specifies the Data Transfer mode.
 *   This parameter can be one of the following values:
 *     @arg SD_DMA_MODE: Data transfer using DMA.
 *     @arg SD_INTERRUPT_MODE: Data transfer using interrupts.
 *     @arg SD_POLLING_MODE: Data transfer using flags.
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_SetDeviceMode ( uint32_t Mode )
{
  SD_Error errorstatus = SD_OK;

  if ( ( Mode == SD_DMA_MODE ) || ( Mode == SD_INTERRUPT_MODE ) ||
    ( Mode == SD_POLLING_MODE ) )
  {
    DeviceMode = Mode;
  }
  else
  {
    errorstatus = SD_INVALID_PARAMETER;
  }
  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 ( uint32_t addr )
{
  SD_Error errorstatus = SD_OK;

  /*!< Send CMD7 SDIO_SEL_DESEL_CARD */
  SDIO_CmdInitStructure.SDIO_Argument = 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.
 * @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.
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_ReadBlock ( uint8_t * readbuff, uint32_t ReadAddr,
  uint16_t BlockSize )
{
  SD_Error errorstatus = SD_OK;
  uint32_t count       = 0, *tempbuff = ( uint32_t* )readbuff;
  uint8_t  power       = 0;

  if ( NULL == readbuff )
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  TransferError = SD_OK;
  TransferEnd        = 0;
  TotalNumberOfBytes = 0;

  /*!< Clear all DPSM configuration */
  SDIO_DataInitStructure.SDIO_DataTimeOut   = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = 0;
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  SDIO_DataInitStructure.SDIO_TransferDir   = SDIO_TransferDir_ToCard;
  SDIO_DataInitStructure.SDIO_TransferMode  = SDIO_TransferMode_Block;
  SDIO_DataInitStructure.SDIO_DPSM          = SDIO_DPSM_Disable;
  SDIO_DataConfig ( & SDIO_DataInitStructure );
  SDIO_DMACmd ( DISABLE );

  if ( SDIO_GetResponse( SDIO_RESP1 ) & SD_CARD_LOCKED )
  {
    errorstatus = SD_LOCK_UNLOCK_FAILED;
    return ( errorstatus );
  }

  if ( CardType == SDIO_HIGH_CAPACITY_SD_CARD )
  {
    BlockSize = 512;
    ReadAddr /= 512;
  }
  if ( ( BlockSize > 0 ) && ( BlockSize <= 2048 ) &&
    ( ( BlockSize & ( BlockSize - 1 ) ) == 0 ) )
  {
    power = convert_from_bytes_to_power_of_two ( BlockSize );

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

    errorstatus = CmdResp1Error ( SD_CMD_SET_BLOCKLEN );

    if ( SD_OK != errorstatus )
    {
      return ( errorstatus );
    }
  }
  else
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = BlockSize;
  SDIO_DataInitStructure.SDIO_DataBlockSize = ( uint32_t ) power << 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 );

  TotalNumberOfBytes = BlockSize;
  StopCondition      = 0;
  DestBuffer         = ( uint32_t* )readbuff;

  /*!< 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 );
  }
  /*!< In case of single block transfer, no need of stop transfer at all.*/
  if ( DeviceMode == SD_POLLING_MODE )
  {
    /*!< 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++ )
        {
          *( tempbuff + count ) = SDIO_ReadData ( );
        }
        tempbuff += 8;
      }
    }

    if ( SDIO_GetFlagStatus( SDIO_FLAG_DTIMEOUT ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_DTIMEOUT );
      errorstatus = SD_DATA_TIMEOUT;
      return ( errorstatus );
    }
    else if ( SDIO_GetFlagStatus( SDIO_FLAG_DCRCFAIL ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_DCRCFAIL );
      errorstatus = SD_DATA_CRC_FAIL;
      return ( errorstatus );
    }
    else if ( SDIO_GetFlagStatus( SDIO_FLAG_RXOVERR ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_RXOVERR );
      errorstatus = SD_RX_OVERRUN;
      return ( errorstatus );
    }
    else if ( SDIO_GetFlagStatus( SDIO_FLAG_STBITERR ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_STBITERR );
      errorstatus = SD_START_BIT_ERR;
      return ( errorstatus );
    }
    while ( SDIO_GetFlagStatus( SDIO_FLAG_RXDAVL ) != RESET )
    {
      *tempbuff = SDIO_ReadData ( );
      tempbuff++;
    }

    /*!< Clear all the static flags */
    SDIO_ClearFlag ( SDIO_STATIC_FLAGS );
  }
  else if ( DeviceMode == SD_INTERRUPT_MODE )
  {
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_RXOVERR | SDIO_IT_RXFIFOHF | SDIO_IT_STBITERR, ENABLE );
    while ( ( TransferEnd == 0 ) && ( TransferError == SD_OK ) )
    {
    }
    if ( TransferError != SD_OK )
    {
      return ( TransferError );
    }
  }
  else if ( DeviceMode == 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 );
    while ( ( SD_DMAEndOfTransferStatus( ) == RESET ) && ( TransferEnd == 0 ) &&
      ( TransferError == SD_OK ) )
    {
    }
    if ( TransferError != SD_OK )
    {
      return ( TransferError );
    }
  }
  return ( errorstatus );
}

/**
 * @brief  Allows to read blocks from a specified address  in a card.
 * @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.
 * @param  NumberOfBlocks: number of blocks to be read.
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_ReadMultiBlocks ( uint8_t * readbuff, uint32_t ReadAddr,
  uint16_t BlockSize, uint32_t NumberOfBlocks )
{
  SD_Error errorstatus = SD_OK;
  uint32_t count       = 0, *tempbuff = ( uint32_t* )readbuff;
  uint8_t  power       = 0;

  if ( NULL == readbuff )
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  TransferError = SD_OK;
  TransferEnd        = 0;
  TotalNumberOfBytes = 0;

  /*!< Clear all DPSM configuration */
  SDIO_DataInitStructure.SDIO_DataTimeOut   = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = 0;
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  SDIO_DataInitStructure.SDIO_TransferDir   = SDIO_TransferDir_ToCard;
  SDIO_DataInitStructure.SDIO_TransferMode  = SDIO_TransferMode_Block;
  SDIO_DataInitStructure.SDIO_DPSM          = SDIO_DPSM_Disable;
  SDIO_DataConfig ( & SDIO_DataInitStructure );
  SDIO_DMACmd ( DISABLE );

  if ( SDIO_GetResponse( SDIO_RESP1 ) & SD_CARD_LOCKED )
  {
    errorstatus = SD_LOCK_UNLOCK_FAILED;
    return ( errorstatus );
  }

  if ( CardType == SDIO_HIGH_CAPACITY_SD_CARD )
  {
    BlockSize = 512;
    ReadAddr /= 512;
  }

  if ( ( BlockSize > 0 ) && ( BlockSize <= 2048 ) &&
    ( 0 == ( BlockSize & ( BlockSize - 1 ) ) ) )
  {
    power = convert_from_bytes_to_power_of_two ( BlockSize );

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

    errorstatus = CmdResp1Error ( SD_CMD_SET_BLOCKLEN );

    if ( SD_OK != errorstatus )
    {
      return ( errorstatus );
    }
  }
  else
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  if ( NumberOfBlocks > 1 )
  {
    /*!< Common to all modes */
    if ( NumberOfBlocks * BlockSize > SD_MAX_DATA_LENGTH )
    {
      errorstatus = SD_INVALID_PARAMETER;
      return ( errorstatus );
    }

    TotalNumberOfBytes = NumberOfBlocks * BlockSize;
    StopCondition = 1;
    DestBuffer    = ( uint32_t* )readbuff;

    SDIO_DataInitStructure.SDIO_DataTimeOut   = SD_DATATIMEOUT;
    SDIO_DataInitStructure.SDIO_DataLength    = NumberOfBlocks * BlockSize;
    SDIO_DataInitStructure.SDIO_DataBlockSize = ( uint32_t ) power << 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 CMD18 READ_MULT_BLOCK with argument data address */
    SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )ReadAddr;
    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 );

    if ( errorstatus != SD_OK )
    {
      return ( errorstatus );
    }

    if ( DeviceMode == SD_POLLING_MODE )
    {
      /*!< Polling mode */
      while ( !( SDIO->STA &
          ( SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DATAEND |
            SDIO_FLAG_DTIMEOUT | SDIO_FLAG_STBITERR ) ) )
      {
        if ( SDIO_GetFlagStatus( SDIO_FLAG_RXFIFOHF ) != RESET )
        {
          for ( count = 0; count < SD_HALFFIFO; count++ )
          {
            *( tempbuff + count ) = SDIO_ReadData ( );
          }
          tempbuff += SD_HALFFIFO;
        }
      }

      if ( SDIO_GetFlagStatus( SDIO_FLAG_DTIMEOUT ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_DTIMEOUT );
        errorstatus = SD_DATA_TIMEOUT;
        return ( errorstatus );
      }
      else if ( SDIO_GetFlagStatus( SDIO_FLAG_DCRCFAIL ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_DCRCFAIL );
        errorstatus = SD_DATA_CRC_FAIL;
        return ( errorstatus );
      }
      else if ( SDIO_GetFlagStatus( SDIO_FLAG_RXOVERR ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_RXOVERR );
        errorstatus = SD_RX_OVERRUN;
        return ( errorstatus );
      }
      else if ( SDIO_GetFlagStatus( SDIO_FLAG_STBITERR ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_STBITERR );
        errorstatus = SD_START_BIT_ERR;
        return ( errorstatus );
      }
      while ( SDIO_GetFlagStatus( SDIO_FLAG_RXDAVL ) != RESET )
      {
        *tempbuff = SDIO_ReadData ( );
        tempbuff++;
      }

      if ( SDIO_GetFlagStatus( SDIO_FLAG_DATAEND ) != RESET )
      {
        /*!< In Case Of SD-CARD Send Command STOP_TRANSMISSION */
        if ( ( SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType ) ||
          ( SDIO_HIGH_CAPACITY_SD_CARD == CardType ) ||
          ( SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType ) )
        {
          /*!< Send CMD12 STOP_TRANSMISSION */
          SDIO_CmdInitStructure.SDIO_Argument = 0x0;
          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 );

          if ( errorstatus != SD_OK )
          {
            return ( errorstatus );
          }
        }
      }
      /*!< Clear all the static flags */
      SDIO_ClearFlag ( SDIO_STATIC_FLAGS );
    }
    else if ( DeviceMode == SD_INTERRUPT_MODE )
    {
      SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
        SDIO_IT_RXOVERR | SDIO_IT_RXFIFOHF | SDIO_IT_STBITERR, ENABLE );
      while ( ( TransferEnd == 0 ) && ( TransferError == SD_OK ) )
      {
      }
      if ( TransferError != SD_OK )
      {
        return ( TransferError );
      }
    }
    else if ( DeviceMode == 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,
        ( NumberOfBlocks * BlockSize ) );
      while ( ( SD_DMAEndOfTransferStatus( ) == RESET ) && ( TransferEnd == 0 )
        && ( TransferError == SD_OK ) )
      {
      }
      if ( TransferError != SD_OK )
      {
        return ( TransferError );
      }
    }
  }
  return ( errorstatus );
}

/**
 * @brief  Allows to write one block starting from a specified address in a card.
 * @param  writebuff: pointer to the buffer that contain the data to be transferred.
 * @param  WriteAddr: Address from where data are to be read.
 * @param  BlockSize: the SD card Data block size.
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_WriteBlock ( uint8_t * writebuff, uint32_t WriteAddr,
  uint16_t BlockSize )
{
  SD_Error   errorstatus = SD_OK;
  uint8_t    power       = 0, cardstate = 0;
  uint32_t   timeout     = 0, bytestransferred = 0;
  uint32_t   cardstatus  = 0, count = 0, restwords = 0;
  uint32_t * tempbuff    = ( uint32_t* )writebuff;

  if ( writebuff == NULL )
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  TransferError = SD_OK;
  TransferEnd        = 0;
  TotalNumberOfBytes = 0;

  SDIO_DataInitStructure.SDIO_DataTimeOut   = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = 0;
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  SDIO_DataInitStructure.SDIO_TransferDir   = SDIO_TransferDir_ToCard;
  SDIO_DataInitStructure.SDIO_TransferMode  = SDIO_TransferMode_Block;
  SDIO_DataInitStructure.SDIO_DPSM          = SDIO_DPSM_Disable;
  SDIO_DataConfig ( & SDIO_DataInitStructure );
  SDIO_DMACmd ( DISABLE );

  if ( SDIO_GetResponse( SDIO_RESP1 ) & SD_CARD_LOCKED )
  {
    errorstatus = SD_LOCK_UNLOCK_FAILED;
    return ( errorstatus );
  }

  if ( CardType == SDIO_HIGH_CAPACITY_SD_CARD )
  {
    BlockSize = 512;
    WriteAddr /= 512;
  }

  /*!< Set the block size, both on controller and card */
  if ( ( BlockSize > 0 ) && ( BlockSize <= 2048 ) &&
    ( ( BlockSize & ( BlockSize - 1 ) ) == 0 ) )
  {
    power = convert_from_bytes_to_power_of_two ( BlockSize );

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

    errorstatus = CmdResp1Error ( SD_CMD_SET_BLOCKLEN );

    if ( errorstatus != SD_OK )
    {
      return ( errorstatus );
    }
  }
  else
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  /*!< Wait till card is ready for data Added */
  SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )( RCA << 16 );
  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 );
  }

  cardstatus = SDIO_GetResponse ( SDIO_RESP1 );

  timeout = SD_DATATIMEOUT;

  while ( ( ( cardstatus & 0x00000100 ) == 0 ) && ( timeout > 0 ) )
  {
    timeout--;
    SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )( RCA << 16 );
    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 );
    }
    cardstatus = SDIO_GetResponse ( SDIO_RESP1 );
  }

  if ( timeout == 0 )
  {
    return ( SD_ERROR );
  }

  /*!< Send CMD24 WRITE_SINGLE_BLOCK */
  SDIO_CmdInitStructure.SDIO_Argument = WriteAddr;
  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 );

  if ( errorstatus != SD_OK )
  {
    return ( errorstatus );
  }

  TotalNumberOfBytes = BlockSize;
  StopCondition = 0;
  SrcBuffer     = ( uint32_t* )writebuff;

  SDIO_DataInitStructure.SDIO_DataTimeOut   = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = BlockSize;
  SDIO_DataInitStructure.SDIO_DataBlockSize = ( uint32_t ) power << 4;
  SDIO_DataInitStructure.SDIO_TransferDir   = SDIO_TransferDir_ToCard;
  SDIO_DataInitStructure.SDIO_TransferMode  = SDIO_TransferMode_Block;
  SDIO_DataInitStructure.SDIO_DPSM          = SDIO_DPSM_Enable;
  SDIO_DataConfig ( & SDIO_DataInitStructure );

  /*!< In case of single data block transfer no need of stop command at all */
  if ( DeviceMode == SD_POLLING_MODE )
  {
    while ( !( SDIO->STA & ( SDIO_FLAG_DBCKEND | SDIO_FLAG_TXUNDERR |
          SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_STBITERR ) ) )
    {
      if ( SDIO_GetFlagStatus( SDIO_FLAG_TXFIFOHE ) != RESET )
      {
        if ( ( TotalNumberOfBytes - bytestransferred ) < 32 )
        {
          restwords = ( ( TotalNumberOfBytes - bytestransferred ) % 4 == 0 ) ?
            ( ( TotalNumberOfBytes - bytestransferred ) / 4 ) :
            ( ( TotalNumberOfBytes - bytestransferred ) / 4 + 1 );

          for ( count = 0; count < restwords;
            count++, tempbuff++, bytestransferred += 4 )
          {
            SDIO_WriteData ( * tempbuff );
          }
        }
        else
        {
          for ( count = 0; count < 8; count++ )
          {
            SDIO_WriteData ( * ( tempbuff + count ) );
          }
          tempbuff += 8;
          bytestransferred += 32;
        }
      }
    }
    if ( SDIO_GetFlagStatus( SDIO_FLAG_DTIMEOUT ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_DTIMEOUT );
      errorstatus = SD_DATA_TIMEOUT;
      return ( errorstatus );
    }
    else if ( SDIO_GetFlagStatus( SDIO_FLAG_DCRCFAIL ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_DCRCFAIL );
      errorstatus = SD_DATA_CRC_FAIL;
      return ( errorstatus );
    }
    else if ( SDIO_GetFlagStatus( SDIO_FLAG_TXUNDERR ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_TXUNDERR );
      errorstatus = SD_TX_UNDERRUN;
      return ( errorstatus );
    }
    else if ( SDIO_GetFlagStatus( SDIO_FLAG_STBITERR ) != RESET )
    {
      SDIO_ClearFlag ( SDIO_FLAG_STBITERR );
      errorstatus = SD_START_BIT_ERR;
      return ( errorstatus );
    }
  }
  else if ( DeviceMode == SD_INTERRUPT_MODE )
  {
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_FLAG_TXFIFOHE | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE );
    while ( ( TransferEnd == 0 ) && ( TransferError == SD_OK ) )
    {
    }
    if ( TransferError != SD_OK )
    {
      return ( TransferError );
    }
  }
  else if ( DeviceMode == SD_DMA_MODE )
  {
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE );
    SD_LowLevel_DMA_TxConfig ( ( uint32_t * )writebuff, BlockSize );
    SDIO_DMACmd ( ENABLE );
    while ( ( SD_DMAEndOfTransferStatus( ) == RESET ) && ( TransferEnd == 0 ) &&
      ( TransferError == SD_OK ) )
    {
    }
    if ( TransferError != SD_OK )
    {
      return ( TransferError );
    }
  }

  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

  /*!< Wait till the card is in programming state */
  errorstatus = IsCardProgramming ( &cardstate );

  while ( ( errorstatus == SD_OK ) && ( ( cardstate == SD_CARD_PROGRAMMING ) ||
      ( cardstate == SD_CARD_RECEIVING ) ) )
  {
    errorstatus = IsCardProgramming ( &cardstate );
  }

  return ( errorstatus );
}

/**
 * @brief  Allows to write blocks starting from a specified address in a card.
 * @param  WriteAddr: Address from where data are to be read.
 * @param  writebuff: pointer to the buffer that contain the data to be transferred.
 * @param  BlockSize: the SD card Data block size.
 * @param  NumberOfBlocks: number of blocks to be written.
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_WriteMultiBlocks ( uint8_t * writebuff, uint32_t WriteAddr,
  uint16_t BlockSize, uint32_t NumberOfBlocks )
{
  SD_Error      errorstatus      = SD_OK;
  uint8_t       power            = 0, cardstate = 0;
  uint32_t      bytestransferred = 0;
  uint32_t      restwords        = 0;
  uint32_t *    tempbuff         = ( uint32_t* )writebuff;
  __IO uint32_t count            = 0;

  if ( writebuff == NULL )
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  TransferError = SD_OK;
  TransferEnd        = 0;
  TotalNumberOfBytes = 0;

  SDIO_DataInitStructure.SDIO_DataTimeOut   = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = 0;
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  SDIO_DataInitStructure.SDIO_TransferDir   = SDIO_TransferDir_ToCard;
  SDIO_DataInitStructure.SDIO_TransferMode  = SDIO_TransferMode_Block;
  SDIO_DataInitStructure.SDIO_DPSM          = SDIO_DPSM_Disable;
  SDIO_DataConfig ( & SDIO_DataInitStructure );
  SDIO_DMACmd ( DISABLE );

  if ( SDIO_GetResponse( SDIO_RESP1 ) & SD_CARD_LOCKED )
  {
    errorstatus = SD_LOCK_UNLOCK_FAILED;
    return ( errorstatus );
  }

  if ( CardType == SDIO_HIGH_CAPACITY_SD_CARD )
  {
    BlockSize = 512;
    WriteAddr /= 512;
  }

  /*!< Set the block size, both on controller and card */
  if ( ( BlockSize > 0 ) && ( BlockSize <= 2048 ) &&
    ( ( BlockSize & ( BlockSize - 1 ) ) == 0 ) )
  {
    power = convert_from_bytes_to_power_of_two ( BlockSize );

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

    errorstatus = CmdResp1Error ( SD_CMD_SET_BLOCKLEN );

    if ( errorstatus != SD_OK )
    {
      return ( errorstatus );
    }
  }
  else
  {
    errorstatus = SD_INVALID_PARAMETER;
    return ( errorstatus );
  }

  /*!< Wait till card is ready for data Added */
  SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )( RCA << 16 );
  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 );
  }

  if ( NumberOfBlocks > 1 )
  {
    /*!< Common to all modes */
    if ( NumberOfBlocks * BlockSize > SD_MAX_DATA_LENGTH )
    {
      errorstatus = SD_INVALID_PARAMETER;
      return ( errorstatus );
    }

    if ( ( SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType ) ||
      ( SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType ) ||
      ( SDIO_HIGH_CAPACITY_SD_CARD == CardType ) )
    {
      /*!< To improve performance */
      SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )( RCA << 16 );
      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 );
      }
      /*!< To improve performance */
      SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )NumberOfBlocks;
      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 );

      if ( errorstatus != SD_OK )
      {
        return ( errorstatus );
      }
    }

    /*!< Send CMD25 WRITE_MULT_BLOCK with argument data address */
    SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )WriteAddr;
    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 );

    if ( SD_OK != errorstatus )
    {
      return ( errorstatus );
    }

    TotalNumberOfBytes = NumberOfBlocks * BlockSize;
    StopCondition = 1;
    SrcBuffer     = ( uint32_t* )writebuff;

    SDIO_DataInitStructure.SDIO_DataTimeOut   = SD_DATATIMEOUT;
    SDIO_DataInitStructure.SDIO_DataLength    = NumberOfBlocks * BlockSize;
    SDIO_DataInitStructure.SDIO_DataBlockSize = ( uint32_t ) power << 4;
    SDIO_DataInitStructure.SDIO_TransferDir   = SDIO_TransferDir_ToCard;
    SDIO_DataInitStructure.SDIO_TransferMode  = SDIO_TransferMode_Block;
    SDIO_DataInitStructure.SDIO_DPSM          = SDIO_DPSM_Enable;
    SDIO_DataConfig ( & SDIO_DataInitStructure );

    if ( DeviceMode == SD_POLLING_MODE )
    {
      while ( !( SDIO->STA &
          ( SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DATAEND |
            SDIO_FLAG_DTIMEOUT | SDIO_FLAG_STBITERR ) ) )
      {
        if ( SDIO_GetFlagStatus( SDIO_FLAG_TXFIFOHE ) != RESET )
        {
          if ( !( ( TotalNumberOfBytes - bytestransferred ) <
              SD_HALFFIFOBYTES ) )
          {
            for ( count = 0; count < SD_HALFFIFO; count++ )
            {
              SDIO_WriteData ( * ( tempbuff + count ) );
            }
            tempbuff += SD_HALFFIFO;
            bytestransferred += SD_HALFFIFOBYTES;
          }
          else
          {
            restwords = ( ( TotalNumberOfBytes - bytestransferred ) % 4 == 0 ) ?
              ( ( TotalNumberOfBytes - bytestransferred ) / 4 ) :
              ( ( TotalNumberOfBytes - bytestransferred ) / 4 + 1 );

            for ( count = 0; count < restwords;
              count++, tempbuff++, bytestransferred += 4 )
            {
              SDIO_WriteData ( * tempbuff );
            }
          }
        }
      }

      if ( SDIO_GetFlagStatus( SDIO_FLAG_DTIMEOUT ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_DTIMEOUT );
        errorstatus = SD_DATA_TIMEOUT;
        return ( errorstatus );
      }
      else if ( SDIO_GetFlagStatus( SDIO_FLAG_DCRCFAIL ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_DCRCFAIL );
        errorstatus = SD_DATA_CRC_FAIL;
        return ( errorstatus );
      }
      else if ( SDIO_GetFlagStatus( SDIO_FLAG_TXUNDERR ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_TXUNDERR );
        errorstatus = SD_TX_UNDERRUN;
        return ( errorstatus );
      }
      else if ( SDIO_GetFlagStatus( SDIO_FLAG_STBITERR ) != RESET )
      {
        SDIO_ClearFlag ( SDIO_FLAG_STBITERR );
        errorstatus = SD_START_BIT_ERR;
        return ( errorstatus );
      }

      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 ) )
        {
          /*!< Send CMD12 STOP_TRANSMISSION */
          SDIO_CmdInitStructure.SDIO_Argument = 0x0;
          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 );

          if ( errorstatus != SD_OK )
          {
            return ( errorstatus );
          }
        }
      }
    }
    else if ( DeviceMode == SD_INTERRUPT_MODE )
    {
      SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
        SDIO_IT_TXFIFOHE | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE );
      while ( ( TransferEnd == 0 ) && ( TransferError == SD_OK ) )
      {
      }
      if ( TransferError != SD_OK )
      {
        return ( TransferError );
      }
    }
    else if ( DeviceMode == SD_DMA_MODE )
    {
      SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
        SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE );
      SDIO_DMACmd ( ENABLE );
      SD_LowLevel_DMA_TxConfig ( ( uint32_t * )writebuff,
        ( NumberOfBlocks * BlockSize ) );
      while ( ( SD_DMAEndOfTransferStatus( ) == RESET ) && ( TransferEnd == 0 )
        && ( TransferError == SD_OK ) )
      {
      }
      if ( TransferError != SD_OK )
      {
        return ( TransferError );
      }
    }
  }
  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

  /*!< Add some delay before checking the Card Status */
  for ( count = 0; count < 0xFFFF; count++ )
  {
  }
  /*!< Wait till the card is in programming state */
  errorstatus = IsCardProgramming ( &cardstate );

  while ( ( errorstatus == SD_OK ) && ( ( cardstate == SD_CARD_PROGRAMMING ) ||
      ( cardstate == SD_CARD_RECEIVING ) ) )
  {
    errorstatus = IsCardProgramming ( &cardstate );
  }

  return ( errorstatus );
}

/**
 * @brief  Gets the cuurent data transfer state.
 * @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_GetTransferState ( void )
{
  if ( SDIO->STA & ( SDIO_FLAG_TXACT | SDIO_FLAG_RXACT ) )
  {
    return ( SD_TRANSFER_BUSY );
  }
  else
  {
    return ( SD_TRANSFER_OK );
  }
}

/**
 * @brief  Aborts an ongoing data transfer.
 * @param  None
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_StopTransfer ( void )
{
  SD_Error errorstatus = SD_OK;

  /*!< Send CMD12 STOP_TRANSMISSION  */
  SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  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 );

  return ( errorstatus );
}

/**
 * @brief  Allows to erase memory area specified for the given card.
 * @param  startaddr: the start address.
 * @param  endaddr: the end address.
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_Erase ( uint32_t startaddr, uint32_t endaddr )
{
  SD_Error      errorstatus = SD_OK;
  uint32_t      delay       = 0;
  __IO uint32_t maxdelay    = 0;
  uint8_t       cardstate   = 0;

  /*!< Check if the card coomnd class supports erase command */
  if ( ( ( CSD_Tab[ 1 ] >> 20 ) & SD_CCCC_ERASE ) == 0 )
  {
    errorstatus = SD_REQUEST_NOT_APPLICABLE;
    return ( errorstatus );
  }

  maxdelay = 120000 / ( ( SDIO->CLKCR & 0xFF ) + 2 );

  if ( SDIO_GetResponse( SDIO_RESP1 ) & SD_CARD_LOCKED )
  {
    errorstatus = SD_LOCK_UNLOCK_FAILED;
    return ( errorstatus );
  }

  if ( CardType == SDIO_HIGH_CAPACITY_SD_CARD )
  {
    startaddr /= 512;
    endaddr /= 512;
  }

  /*!< According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
  if ( ( SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType ) ||
    ( SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType ) ||
    ( SDIO_HIGH_CAPACITY_SD_CARD == CardType ) )
  {
    /*!< Send CMD32 SD_ERASE_GRP_START with argument as addr  */
    SDIO_CmdInitStructure.SDIO_Argument = startaddr;
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_ERASE_GRP_START;
    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_SD_ERASE_GRP_START );
    if ( errorstatus != SD_OK )
    {
      return ( errorstatus );
    }

    /*!< Send CMD33 SD_ERASE_GRP_END with argument as addr  */
    SDIO_CmdInitStructure.SDIO_Argument = endaddr;
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_ERASE_GRP_END;
    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_SD_ERASE_GRP_END );
    if ( errorstatus != SD_OK )
    {
      return ( errorstatus );
    }
  }

  /*!< Send CMD38 ERASE */
  SDIO_CmdInitStructure.SDIO_Argument = 0;
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ERASE;
  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_ERASE );

  if ( errorstatus != SD_OK )
  {
    return ( errorstatus );
  }

  for ( delay = 0; delay < maxdelay; delay++ )
  {
  }

  /*!< Wait till the card is in programming state */
  errorstatus = IsCardProgramming ( &cardstate );

  while ( ( errorstatus == SD_OK ) && ( ( SD_CARD_PROGRAMMING == cardstate ) ||
      ( SD_CARD_RECEIVING == cardstate ) ) )
  {
    errorstatus = IsCardProgramming ( &cardstate );
  }

  return ( errorstatus );
}

/**
 * @brief  Returns the current card's status.
 * @param  pcardstatus: pointer to the buffer that will contain the SD card
 *         status (Card Status register).
 * @retval SD_Error: SD Card Error code.
 */
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;
  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_GetResponse ( SDIO_RESP1 );

  return ( errorstatus );
}

/**
 * @brief  Returns the current SD card's status.
 * @param  psdstatus: pointer to the buffer that will contain the SD card status
 *         (SD Status register).
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_SendSDStatus ( uint32_t * psdstatus )
{
  SD_Error errorstatus = SD_OK;
  uint32_t count       = 0;

  if ( SDIO_GetResponse( SDIO_RESP1 ) & SD_CARD_LOCKED )
  {
    errorstatus = SD_LOCK_UNLOCK_FAILED;
    return ( errorstatus );
  }

  /*!< Set block size for card if it is not equal to current block size for card. */
  SDIO_CmdInitStructure.SDIO_Argument = 64;
  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 );

  if ( errorstatus != SD_OK )
  {
    return ( errorstatus );
  }

  /*!< CMD55 */
  SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t ) RCA << 16;
  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_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = 64;
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_64b;
  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 ACMD13 SD_APP_STAUS  with argument as card's RCA.*/
  SDIO_CmdInitStructure.SDIO_Argument = 0;
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_STAUS;
  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_SD_APP_STAUS );

  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_RXFIFOHF ) != RESET )
    {
      for ( count = 0; count < 8; count++ )
      {
        *( psdstatus + count ) = SDIO_ReadData ( );
      }
      psdstatus += 8;
    }
  }

  if ( SDIO_GetFlagStatus( SDIO_FLAG_DTIMEOUT ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_DTIMEOUT );
    errorstatus = SD_DATA_TIMEOUT;
    return ( errorstatus );
  }
  else if ( SDIO_GetFlagStatus( SDIO_FLAG_DCRCFAIL ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_DCRCFAIL );
    errorstatus = SD_DATA_CRC_FAIL;
    return ( errorstatus );
  }
  else if ( SDIO_GetFlagStatus( SDIO_FLAG_RXOVERR ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_RXOVERR );
    errorstatus = SD_RX_OVERRUN;
    return ( errorstatus );
  }
  else if ( SDIO_GetFlagStatus( SDIO_FLAG_STBITERR ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_STBITERR );
    errorstatus = SD_START_BIT_ERR;
    return ( errorstatus );
  }

  while ( SDIO_GetFlagStatus( SDIO_FLAG_RXDAVL ) != RESET )
  {
    *psdstatus = SDIO_ReadData ( );
    psdstatus++;
  }

  /*!< Clear all the static status flags*/
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );
  psdstatus -= 16;
  for ( count = 0; count < 16; count++ )
  {
    psdstatus[ count ] = ( ( psdstatus[ count ] & SD_0TO7BITS ) << 24 ) |
      ( ( psdstatus[ count ] & SD_8TO15BITS ) << 8 ) |
      ( ( psdstatus[ count ] & SD_16TO23BITS ) >> 8 ) |
      ( ( psdstatus[ count ] & SD_24TO31BITS ) >> 24 );
  }
  return ( errorstatus );
}

/**
 * @brief  Allows to process all the interrupts that are high.
 * @param  None
 * @retval SD_Error: SD Card Error code.
 */
SD_Error SD_ProcessIRQSrc ( void )
{
  uint32_t count = 0, restwords = 0;

  if ( DeviceMode == SD_INTERRUPT_MODE )
  {
    if ( SDIO_GetITStatus( SDIO_IT_RXFIFOHF ) != RESET )
    {
      for ( count = 0; count < SD_HALFFIFO; count++ )
      {
        *( DestBuffer + count ) = SDIO_ReadData ( );
      }
      DestBuffer += SD_HALFFIFO;
      NumberOfBytes += SD_HALFFIFOBYTES;
    }
    else if ( SDIO_GetITStatus( SDIO_IT_TXFIFOHE ) != RESET )
    {
      if ( ( TotalNumberOfBytes - NumberOfBytes ) < SD_HALFFIFOBYTES )
      {
        restwords = ( ( TotalNumberOfBytes - NumberOfBytes ) % 4 == 0 ) ?
          ( ( TotalNumberOfBytes - NumberOfBytes ) / 4 ) :
          ( ( TotalNumberOfBytes - NumberOfBytes ) / 4 + 1 );

        for ( count = 0; count < restwords; count++, SrcBuffer++,
          NumberOfBytes += 4 )
        {
          SDIO_WriteData ( * SrcBuffer );
        }
      }
      else
      {
        for ( count = 0; count < SD_HALFFIFO; count++ )
        {
          SDIO_WriteData ( * ( SrcBuffer + count ) );
        }

        SrcBuffer += SD_HALFFIFO;
        NumberOfBytes += SD_HALFFIFOBYTES;
      }
    }
  }

  if ( SDIO_GetITStatus( SDIO_IT_DATAEND ) != RESET )
  {
    if ( DeviceMode != SD_DMA_MODE )
    {
      while ( ( SDIO_GetFlagStatus( SDIO_FLAG_RXDAVL ) != RESET ) &&
        ( NumberOfBytes < TotalNumberOfBytes ) )
      {
        *DestBuffer = SDIO_ReadData ( );
        DestBuffer++;
        NumberOfBytes += 4;
      }
    }

    if ( StopCondition == 1 )
    {
      TransferError = SD_StopTransfer ( );
    }
    else
    {
      TransferError = SD_OK;
    }
    SDIO_ClearITPendingBit ( SDIO_IT_DATAEND );
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR |
      SDIO_IT_STBITERR, DISABLE );
    TransferEnd   = 1;
    NumberOfBytes = 0;
    return ( TransferError );
  }

  if ( SDIO_GetITStatus( SDIO_IT_DCRCFAIL ) != RESET )
  {
    SDIO_ClearITPendingBit ( SDIO_IT_DCRCFAIL );
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR |
      SDIO_IT_STBITERR, DISABLE );
    NumberOfBytes = 0;
    TransferError = SD_DATA_CRC_FAIL;
    return ( SD_DATA_CRC_FAIL );
  }

  if ( SDIO_GetITStatus( SDIO_IT_DTIMEOUT ) != RESET )
  {
    SDIO_ClearITPendingBit ( SDIO_IT_DTIMEOUT );
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR |
      SDIO_IT_STBITERR, DISABLE );
    NumberOfBytes = 0;
    TransferError = SD_DATA_TIMEOUT;
    return ( SD_DATA_TIMEOUT );
  }

  if ( SDIO_GetITStatus( SDIO_IT_RXOVERR ) != RESET )
  {
    SDIO_ClearITPendingBit ( SDIO_IT_RXOVERR );
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR |
      SDIO_IT_STBITERR, DISABLE );
    NumberOfBytes = 0;
    TransferError = SD_RX_OVERRUN;
    return ( SD_RX_OVERRUN );
  }

  if ( SDIO_GetITStatus( SDIO_IT_TXUNDERR ) != RESET )
  {
    SDIO_ClearITPendingBit ( SDIO_IT_TXUNDERR );
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR |
      SDIO_IT_STBITERR, DISABLE );
    NumberOfBytes = 0;
    TransferError = SD_TX_UNDERRUN;
    return ( SD_TX_UNDERRUN );
  }

  if ( SDIO_GetITStatus( SDIO_IT_STBITERR ) != RESET )
  {
    SDIO_ClearITPendingBit ( SDIO_IT_STBITERR );
    SDIO_ITConfig ( SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
      SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR |
      SDIO_IT_STBITERR, DISABLE );
    NumberOfBytes = 0;
    TransferError = SD_START_BIT_ERR;
    return ( SD_START_BIT_ERR );
  }

  return ( SD_OK );
}

/**
 * @brief  Checks for error conditions for CMD0.
 * @param  None
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error CmdError ( void )
{
  SD_Error errorstatus = SD_OK;
  uint32_t timeout;

  timeout = SDIO_CMD0TIMEOUT; /*!< 10000 */

  while ( ( timeout > 0 ) && ( SDIO_GetFlagStatus( SDIO_FLAG_CMDSENT )
      == RESET ) )
  {
    timeout--;
  }

  if ( timeout == 0 )
  {
    errorstatus = SD_CMD_RSP_TIMEOUT;
    return ( errorstatus );
  }

  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

  return ( errorstatus );
}

/**
 * @brief  Checks for error conditions for R7 response.
 * @param  None
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error CmdResp7Error ( void )
{
  SD_Error errorstatus = SD_OK;
  uint32_t status;
  uint32_t timeout = SDIO_CMD0TIMEOUT;

  status = SDIO->STA;

  while ( !( status & ( SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND |
        SDIO_FLAG_CTIMEOUT ) ) && ( timeout > 0 ) )
  {
    timeout--;
    status = SDIO->STA;
  }

  if ( ( timeout == 0 ) || ( status & SDIO_FLAG_CTIMEOUT ) )
  {
    /*!< Card is not V2.0 complient or card does not support the set voltage range */
    errorstatus = SD_CMD_RSP_TIMEOUT;
    SDIO_ClearFlag ( SDIO_FLAG_CTIMEOUT );
    return ( errorstatus );
  }

  if ( status & SDIO_FLAG_CMDREND )
  {
    /*!< Card is SD V2.0 compliant */
    errorstatus = SD_OK;
    SDIO_ClearFlag ( SDIO_FLAG_CMDREND );
    return ( errorstatus );
  }
  return ( errorstatus );
}

/**
 * @brief  Checks for error conditions for R1 response.
 * @param  cmd: The sent command index.
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error CmdResp1Error ( uint8_t cmd )
{
  SD_Error errorstatus = SD_OK;
  uint32_t status;
  uint32_t response_r1;

  status = SDIO->STA;

  while ( !( status & ( SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND |
        SDIO_FLAG_CTIMEOUT ) ) )
  {
    status = SDIO->STA;
  }

  if ( status & SDIO_FLAG_CTIMEOUT )
  {
    errorstatus = SD_CMD_RSP_TIMEOUT;
    SDIO_ClearFlag ( SDIO_FLAG_CTIMEOUT );
    return ( errorstatus );
  }
  else if ( status & SDIO_FLAG_CCRCFAIL )
  {
    errorstatus = SD_CMD_CRC_FAIL;
    SDIO_ClearFlag ( SDIO_FLAG_CCRCFAIL );
    return ( errorstatus );
  }

  /*!< Check response received is of desired command */
  if ( SDIO_GetCommandResponse( ) != cmd )
  {
    errorstatus = SD_ILLEGAL_CMD;
    return ( errorstatus );
  }

  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

  /*!< We have received response, retrieve it for analysis  */
  response_r1 = SDIO_GetResponse ( SDIO_RESP1 );

  if ( ( response_r1 & SD_OCR_ERRORBITS ) == SD_ALLZERO )
  {
    return ( errorstatus );
  }

  if ( response_r1 & SD_OCR_ADDR_OUT_OF_RANGE )
  {
    return ( SD_ADDR_OUT_OF_RANGE );
  }

  if ( response_r1 & SD_OCR_ADDR_MISALIGNED )
  {
    return ( SD_ADDR_MISALIGNED );
  }

  if ( response_r1 & SD_OCR_BLOCK_LEN_ERR )
  {
    return ( SD_BLOCK_LEN_ERR );
  }

  if ( response_r1 & SD_OCR_ERASE_SEQ_ERR )
  {
    return ( SD_ERASE_SEQ_ERR );
  }

  if ( response_r1 & SD_OCR_BAD_ERASE_PARAM )
  {
    return ( SD_BAD_ERASE_PARAM );
  }

  if ( response_r1 & SD_OCR_WRITE_PROT_VIOLATION )
  {
    return ( SD_WRITE_PROT_VIOLATION );
  }

  if ( response_r1 & SD_OCR_LOCK_UNLOCK_FAILED )
  {
    return ( SD_LOCK_UNLOCK_FAILED );
  }

  if ( response_r1 & SD_OCR_COM_CRC_FAILED )
  {
    return ( SD_COM_CRC_FAILED );
  }

  if ( response_r1 & SD_OCR_ILLEGAL_CMD )
  {
    return ( SD_ILLEGAL_CMD );
  }

  if ( response_r1 & SD_OCR_CARD_ECC_FAILED )
  {
    return ( SD_CARD_ECC_FAILED );
  }

  if ( response_r1 & SD_OCR_CC_ERROR )
  {
    return ( SD_CC_ERROR );
  }

  if ( response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR )
  {
    return ( SD_GENERAL_UNKNOWN_ERROR );
  }

  if ( response_r1 & SD_OCR_STREAM_READ_UNDERRUN )
  {
    return ( SD_STREAM_READ_UNDERRUN );
  }

  if ( response_r1 & SD_OCR_STREAM_WRITE_OVERRUN )
  {
    return ( SD_STREAM_WRITE_OVERRUN );
  }

  if ( response_r1 & SD_OCR_CID_CSD_OVERWRIETE )
  {
    return ( SD_CID_CSD_OVERWRITE );
  }

  if ( response_r1 & SD_OCR_WP_ERASE_SKIP )
  {
    return ( SD_WP_ERASE_SKIP );
  }

  if ( response_r1 & SD_OCR_CARD_ECC_DISABLED )
  {
    return ( SD_CARD_ECC_DISABLED );
  }

  if ( response_r1 & SD_OCR_ERASE_RESET )
  {
    return ( SD_ERASE_RESET );
  }

  if ( response_r1 & SD_OCR_AKE_SEQ_ERROR )
  {
    return ( SD_AKE_SEQ_ERROR );
  }
  return ( errorstatus );
}

/**
 * @brief  Checks for error conditions for R3 (OCR) response.
 * @param  None
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error CmdResp3Error ( void )
{
  SD_Error errorstatus = SD_OK;
  uint32_t status;

  status = SDIO->STA;

  while ( !( status & ( SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND |
        SDIO_FLAG_CTIMEOUT ) ) )
  {
    status = SDIO->STA;
  }

  if ( status & SDIO_FLAG_CTIMEOUT )
  {
    errorstatus = SD_CMD_RSP_TIMEOUT;
    SDIO_ClearFlag ( SDIO_FLAG_CTIMEOUT );
    return ( errorstatus );
  }
  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );
  return ( errorstatus );
}

/**
 * @brief  Checks for error conditions for R2 (CID or CSD) response.
 * @param  None
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error CmdResp2Error ( void )
{
  SD_Error errorstatus = SD_OK;
  uint32_t status;

  status = SDIO->STA;

  while ( !( status & ( SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT |
        SDIO_FLAG_CMDREND ) ) )
  {
    status = SDIO->STA;
  }

  if ( status & SDIO_FLAG_CTIMEOUT )
  {
    errorstatus = SD_CMD_RSP_TIMEOUT;
    SDIO_ClearFlag ( SDIO_FLAG_CTIMEOUT );
    return ( errorstatus );
  }
  else if ( status & SDIO_FLAG_CCRCFAIL )
  {
    errorstatus = SD_CMD_CRC_FAIL;
    SDIO_ClearFlag ( SDIO_FLAG_CCRCFAIL );
    return ( errorstatus );
  }

  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

  return ( errorstatus );
}

/**
 * @brief  Checks for error conditions for R6 (RCA) response.
 * @param  cmd: The sent command index.
 * @param  prca: pointer to the variable that will contain the SD card relative
 *         address RCA.
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error CmdResp6Error ( uint8_t cmd, uint16_t * prca )
{
  SD_Error errorstatus = SD_OK;
  uint32_t status;
  uint32_t response_r1;

  status = SDIO->STA;

  while ( !( status & ( SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT |
        SDIO_FLAG_CMDREND ) ) )
  {
    status = SDIO->STA;
  }

  if ( status & SDIO_FLAG_CTIMEOUT )
  {
    errorstatus = SD_CMD_RSP_TIMEOUT;
    SDIO_ClearFlag ( SDIO_FLAG_CTIMEOUT );
    return ( errorstatus );
  }
  else if ( status & SDIO_FLAG_CCRCFAIL )
  {
    errorstatus = SD_CMD_CRC_FAIL;
    SDIO_ClearFlag ( SDIO_FLAG_CCRCFAIL );
    return ( errorstatus );
  }

  /*!< Check response received is of desired command */
  if ( SDIO_GetCommandResponse( ) != cmd )
  {
    errorstatus = SD_ILLEGAL_CMD;
    return ( errorstatus );
  }

  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

  /*!< We have received response, retrieve it.  */
  response_r1 = SDIO_GetResponse ( SDIO_RESP1 );

  if ( SD_ALLZERO == ( response_r1 &
      ( SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD |
        SD_R6_COM_CRC_FAILED ) ) )
  {
    *prca = ( uint16_t )( response_r1 >> 16 );
    return ( errorstatus );
  }

  if ( response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR )
  {
    return ( SD_GENERAL_UNKNOWN_ERROR );
  }

  if ( response_r1 & SD_R6_ILLEGAL_CMD )
  {
    return ( SD_ILLEGAL_CMD );
  }

  if ( response_r1 & SD_R6_COM_CRC_FAILED )
  {
    return ( SD_COM_CRC_FAILED );
  }

  return ( errorstatus );
}

/**
 * @brief  Enables or disables the SDIO wide bus mode.
 * @param  NewState: new state of the SDIO wide bus mode.
 *   This parameter can be: ENABLE or DISABLE.
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error SDEnWideBus ( FunctionalState NewState )
{
  SD_Error errorstatus = SD_OK;

  uint32_t scr[ 2 ] =
  {
    0,
    0
  } ;

  if ( SDIO_GetResponse( SDIO_RESP1 ) & SD_CARD_LOCKED )
  {
    errorstatus = SD_LOCK_UNLOCK_FAILED;
    return ( errorstatus );
  }

  /*!< Get SCR Register */
  errorstatus = FindSCR ( RCA, scr );

  if ( errorstatus != SD_OK )
  {
    return ( errorstatus );
  }

  /*!< If wide bus operation to be enabled */
  if ( NewState == ENABLE )
  {
    /*!< If requested card supports wide bus operation */
    if ( ( scr[ 1 ] & SD_WIDE_BUS_SUPPORT ) != SD_ALLZERO )
    {
      /*!< Send CMD55 APP_CMD with argument as card's RCA.*/
      SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t ) RCA << 16;
      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 );
      }

      /*!< Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
      SDIO_CmdInitStructure.SDIO_Argument = 0x2;
      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 );

      if ( errorstatus != SD_OK )
      {
        return ( errorstatus );
      }
      return ( errorstatus );
    }
    else
    {
      errorstatus = SD_REQUEST_NOT_APPLICABLE;
      return ( errorstatus );
    }
  } /*!< If wide bus operation to be disabled */
  else
  {
    /*!< If requested card supports 1 bit mode operation */
    if ( ( scr[ 1 ] & SD_SINGLE_BUS_SUPPORT ) != SD_ALLZERO )
    {
      /*!< Send CMD55 APP_CMD with argument as card's RCA.*/
      SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t ) RCA << 16;
      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 );
      }

      /*!< Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
      SDIO_CmdInitStructure.SDIO_Argument = 0x00;
      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 );

      if ( errorstatus != SD_OK )
      {
        return ( errorstatus );
      }

      return ( errorstatus );
    }
    else
    {
      errorstatus = SD_REQUEST_NOT_APPLICABLE;
      return ( errorstatus );
    }
  }
}

/**
 * @brief  Checks if the SD card is in programming state.
 * @param  pstatus: pointer to the variable that will contain the SD card state.
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error IsCardProgramming ( uint8_t * pstatus )
{
  SD_Error      errorstatus = SD_OK;
  __IO uint32_t respR1      = 0, status = 0;

  SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t ) RCA << 16;
  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 );

  status = SDIO->STA;
  while ( !( status & ( SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND |
        SDIO_FLAG_CTIMEOUT ) ) )
  {
    status = SDIO->STA;
  }

  if ( status & SDIO_FLAG_CTIMEOUT )
  {
    errorstatus = SD_CMD_RSP_TIMEOUT;
    SDIO_ClearFlag ( SDIO_FLAG_CTIMEOUT );
    return ( errorstatus );
  }
  else if ( status & SDIO_FLAG_CCRCFAIL )
  {
    errorstatus = SD_CMD_CRC_FAIL;
    SDIO_ClearFlag ( SDIO_FLAG_CCRCFAIL );
    return ( errorstatus );
  }

  status = ( uint32_t )SDIO_GetCommandResponse ( );

  /*!< Check response received is of desired command */
  if ( status != SD_CMD_SEND_STATUS )
  {
    errorstatus = SD_ILLEGAL_CMD;
    return ( errorstatus );
  }

  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

  /*!< We have received response, retrieve it for analysis  */
  respR1 = SDIO_GetResponse ( SDIO_RESP1 );

  /*!< Find out card status */
  *pstatus = ( uint8_t )( ( respR1 >> 9 ) & 0x0000000F );

  if ( ( respR1 & SD_OCR_ERRORBITS ) == SD_ALLZERO )
  {
    return ( errorstatus );
  }

  if ( respR1 & SD_OCR_ADDR_OUT_OF_RANGE )
  {
    return ( SD_ADDR_OUT_OF_RANGE );
  }

  if ( respR1 & SD_OCR_ADDR_MISALIGNED )
  {
    return ( SD_ADDR_MISALIGNED );
  }

  if ( respR1 & SD_OCR_BLOCK_LEN_ERR )
  {
    return ( SD_BLOCK_LEN_ERR );
  }

  if ( respR1 & SD_OCR_ERASE_SEQ_ERR )
  {
    return ( SD_ERASE_SEQ_ERR );
  }

  if ( respR1 & SD_OCR_BAD_ERASE_PARAM )
  {
    return ( SD_BAD_ERASE_PARAM );
  }

  if ( respR1 & SD_OCR_WRITE_PROT_VIOLATION )
  {
    return ( SD_WRITE_PROT_VIOLATION );
  }

  if ( respR1 & SD_OCR_LOCK_UNLOCK_FAILED )
  {
    return ( SD_LOCK_UNLOCK_FAILED );
  }

  if ( respR1 & SD_OCR_COM_CRC_FAILED )
  {
    return ( SD_COM_CRC_FAILED );
  }

  if ( respR1 & SD_OCR_ILLEGAL_CMD )
  {
    return ( SD_ILLEGAL_CMD );
  }

  if ( respR1 & SD_OCR_CARD_ECC_FAILED )
  {
    return ( SD_CARD_ECC_FAILED );
  }

  if ( respR1 & SD_OCR_CC_ERROR )
  {
    return ( SD_CC_ERROR );
  }

  if ( respR1 & SD_OCR_GENERAL_UNKNOWN_ERROR )
  {
    return ( SD_GENERAL_UNKNOWN_ERROR );
  }

  if ( respR1 & SD_OCR_STREAM_READ_UNDERRUN )
  {
    return ( SD_STREAM_READ_UNDERRUN );
  }

  if ( respR1 & SD_OCR_STREAM_WRITE_OVERRUN )
  {
    return ( SD_STREAM_WRITE_OVERRUN );
  }

  if ( respR1 & SD_OCR_CID_CSD_OVERWRIETE )
  {
    return ( SD_CID_CSD_OVERWRITE );
  }

  if ( respR1 & SD_OCR_WP_ERASE_SKIP )
  {
    return ( SD_WP_ERASE_SKIP );
  }

  if ( respR1 & SD_OCR_CARD_ECC_DISABLED )
  {
    return ( SD_CARD_ECC_DISABLED );
  }

  if ( respR1 & SD_OCR_ERASE_RESET )
  {
    return ( SD_ERASE_RESET );
  }

  if ( respR1 & SD_OCR_AKE_SEQ_ERROR )
  {
    return ( SD_AKE_SEQ_ERROR );
  }

  return ( errorstatus );
}

/**
 * @brief  Find the SD card SCR register value.
 * @param  rca: selected card address.
 * @param  pscr: pointer to the buffer that will contain the SCR value.
 * @retval SD_Error: SD Card Error code.
 */
static SD_Error FindSCR ( uint16_t rca, uint32_t * pscr )
{
  uint32_t index        = 0;
  SD_Error errorstatus  = SD_OK;
  uint32_t tempscr[ 2 ] =
  {
    0,
    0
  } ;

  /*!< Set Block Size To 8 Bytes */
  /*!< Send CMD55 APP_CMD with argument as card's RCA */
  SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t )8;
  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 );

  if ( errorstatus != SD_OK )
  {
    return ( errorstatus );
  }

  /*!< Send CMD55 APP_CMD with argument as card's RCA */
  SDIO_CmdInitStructure.SDIO_Argument = ( uint32_t ) RCA << 16;
  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_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  SDIO_DataInitStructure.SDIO_DataLength    = 8;
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b;
  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 ACMD51 SD_APP_SEND_SCR with argument as 0 */
  SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_SEND_SCR;
  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_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 )
    {
      *( tempscr + index ) = SDIO_ReadData ( );
      index++;
    }
  }

  if ( SDIO_GetFlagStatus( SDIO_FLAG_DTIMEOUT ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_DTIMEOUT );
    errorstatus = SD_DATA_TIMEOUT;
    return ( errorstatus );
  }
  else if ( SDIO_GetFlagStatus( SDIO_FLAG_DCRCFAIL ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_DCRCFAIL );
    errorstatus = SD_DATA_CRC_FAIL;
    return ( errorstatus );
  }
  else if ( SDIO_GetFlagStatus( SDIO_FLAG_RXOVERR ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_RXOVERR );
    errorstatus = SD_RX_OVERRUN;
    return ( errorstatus );
  }
  else if ( SDIO_GetFlagStatus( SDIO_FLAG_STBITERR ) != RESET )
  {
    SDIO_ClearFlag ( SDIO_FLAG_STBITERR );
    errorstatus = SD_START_BIT_ERR;
    return ( errorstatus );
  }

  /*!< Clear all the static flags */
  SDIO_ClearFlag ( SDIO_STATIC_FLAGS );

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

/**
 * @brief  Converts the number of bytes in power of two and returns the power.
 * @param  NumberOfBytes: number of bytes.
 * @retval None
 */
static uint8_t convert_from_bytes_to_power_of_two ( uint16_t NumberOfBytes )
{
  uint8_t count = 0;

  while ( NumberOfBytes != 1 )
  {
    NumberOfBytes >>= 1;
    count++;
  }
  return ( count );
}

/**
 * @}
 */

/**
 * @}
 */

/**
 * @}
 */

/**
 * @}
 */

/**
 * @}
 */

/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE****/

/****************************************Copyright (c)****************************************************
 **
 **                                 http://www.powermcu.com
 **
 **--------------File Info---------------------------------------------------------------------------------
 ** File name:               sdio_sd.h
 ** Descriptions:            sdio sd卡操作头文件
 **
 **--------------------------------------------------------------------------------------------------------
 ** Created by:              AVRman
 ** Created date:            2010-10-30
 ** Version:                 v1.0
 ** Descriptions:            The original version
 **
 **--------------------------------------------------------------------------------------------------------
 ** Modified by:
 ** Modified date:
 ** Version:
 ** Descriptions:
 **
 *********************************************************************************************************/

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __SDIO_SD_H
#define __SDIO_SD_H

#ifdef __cplusplus
extern "C"
{
  #endif

  /* Includes ------------------------------------------------------------------*/
  #include "stm32f10x.h"

  typedef enum
  {
    /**
     * @brief  SDIO specific error defines
     */
    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
  } 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 information
   */
  typedef struct
  {
    SD_CSD SD_csd;
    SD_CID SD_cid;
    uint32_t CardCapacity;  /*!< Card Capacity */
    uint32_t CardBlockSize; /*!< Card Block Size */
    uint16_t RCA;
    uint8_t CardType;
  } SD_CardInfo;

  /**
   * @brief  SDIO Data Transfer Frequency (25MHz max)
   */
  #define SDIO_TRANSFER_CLK_DIV            ((uint8_t)0x1)

  #define SD_DETECT_PIN                    GPIO_Pin_14                 /* PB.14 */
  #define SD_DETECT_GPIO_PORT              GPIOB                       /* GPIOB */
  #define SD_DETECT_GPIO_CLK               RCC_APB2Periph_GPIOB

  /**
   * @brief  SDIO Intialization Frequency (400KHz max)
   */
  #define SDIO_INIT_CLK_DIV                ((uint8_t)0xB2)
  #define SDIO_FIFO_ADDRESS                ((uint32_t)0x40018080)

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

    #define SD_DMA_MODE                                ((uint32_t)0x00000000)
    #define SD_INTERRUPT_MODE                          ((uint32_t)0x00000001)
    #define SD_POLLING_MODE                            ((uint32_t)0x00000002)

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

    /* Private 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_EnableWideBusOperation ( uint32_t WideMode );
  SD_Error SD_SetDeviceMode ( uint32_t Mode );
  SD_Error SD_SelectDeselect ( uint32_t addr );
  SD_Error SD_ReadBlock ( uint8_t * readbuff, uint32_t ReadAddr,
    uint16_t BlockSize );
  SD_Error SD_ReadMultiBlocks ( uint8_t * readbuff, uint32_t ReadAddr,
    uint16_t BlockSize, uint32_t NumberOfBlocks );
  SD_Error SD_WriteBlock ( uint8_t * writebuff, uint32_t WriteAddr,
    uint16_t BlockSize );
  SD_Error SD_WriteMultiBlocks ( uint8_t * writebuff, uint32_t WriteAddr,
    uint16_t BlockSize, uint32_t NumberOfBlocks );
  SDTransferState SD_GetTransferState ( void );
  SD_Error SD_StopTransfer ( void );
  SD_Error SD_Erase ( uint32_t startaddr, uint32_t endaddr );
  SD_Error SD_SendStatus ( uint32_t * pcardstatus );
  SD_Error SD_SendSDStatus ( uint32_t * psdstatus );
  SD_Error SD_ProcessIRQSrc ( void );

  #ifdef __cplusplus
}
#endif

#endif /* __SDIO_SD_H */

/*********************************************************************************************************
 END FILE
 *********************************************************************************************************/