STM32CubeMX/SCSI2SD-V6/Drivers/STM32F2xx_HAL_Driver/Src/stm32f2xx_hal_sd.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f2xx_hal_sd.c
   4   * @author  MCD Application Team
   5   * @version V1.1.0
   6   * @date    09-October-2015
   7   * @brief   SD card HAL module driver.
   8   *          This file provides firmware functions to manage the following
   9   *          functionalities of the Secure Digital (SD) peripheral:
  10   *           + Initialization and de-initialization functions
  11   *           + IO operation functions
  12   *           + Peripheral Control functions
  13   *           + Peripheral State functions
  14   *
  15   @verbatim
  16   ==============================================================================
  17                         ##### How to use this driver #####
  18   ==============================================================================
  19   [..]
  20     This driver implements a high level communication layer for read and write from/to
  21     this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by
  22     the user in HAL_SD_MspInit() function (MSP layer).
  23     Basically, the MSP layer configuration should be the same as we provide in the
  24     examples.
  25     You can easily tailor this configuration according to hardware resources.
  26
  27   [..]
  28     This driver is a generic layered driver for SDIO memories which uses the HAL
  29     SDIO driver functions to interface with SD and uSD cards devices.
  30     It is used as follows:
  31
  32     (#)Initialize the SDIO low level resources by implement the HAL_SD_MspInit() API:
  33         (##) Enable the SDIO interface clock using __HAL_RCC_SDIO_CLK_ENABLE();
  34         (##) SDIO pins configuration for SD card
  35             (+++) Enable the clock for the SDIO GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
  36             (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()
  37                   and according to your pin assignment;
  38         (##) DMA Configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
  39              and HAL_SD_WriteBlocks_DMA() APIs).
  40             (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();
  41             (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.
  42         (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
  43             (+++) Configure the SDIO and DMA interrupt priorities using functions
  44                   HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority
  45             (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()
  46             (+++) SDIO interrupts are managed using the macros __HAL_SD_SDIO_ENABLE_IT()
  47                   and __HAL_SD_SDIO_DISABLE_IT() inside the communication process.
  48             (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_SDIO_GET_IT()
  49                   and __HAL_SD_SDIO_CLEAR_IT()
  50     (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
  51
  52
  53   *** SD Card Initialization and configuration ***
  54   ================================================
  55   [..]
  56     To initialize the SD Card, use the HAL_SD_Init() function.  It Initializes
  57     the SD Card and put it into Standby State (Ready for data transfer).
  58     This function provide the following operations:
  59
  60     (#) Apply the SD Card initialization process at 400KHz and check the SD Card
  61         type (Standard Capacity or High Capacity). You can change or adapt this
  62         frequency by adjusting the "ClockDiv" field.
  63         The SD Card frequency (SDIO_CK) is computed as follows:
  64
  65            SDIO_CK = SDIOCLK / (ClockDiv + 2)
  66
  67         In initialization mode and according to the SD Card standard,
  68         make sure that the SDIO_CK frequency doesn't exceed 400KHz.
  69
  70     (#) Get the SD CID and CSD data. All these information are managed by the SDCardInfo
  71         structure. This structure provide also ready computed SD Card capacity
  72         and Block size.
  73
  74         -@- These information are stored in SD handle structure in case of future use.
  75
  76     (#) Configure the SD Card Data transfer frequency. By Default, the card transfer
  77         frequency is set to 24MHz. You can change or adapt this frequency by adjusting
  78         the "ClockDiv" field.
  79         In transfer mode and according to the SD Card standard, make sure that the
  80         SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
  81         To be able to use a frequency higher than 24MHz, you should use the SDIO
  82         peripheral in bypass mode. Refer to the corresponding reference manual
  83         for more details.
  84
  85     (#) Select the corresponding SD Card according to the address read with the step 2.
  86
  87     (#) Configure the SD Card in wide bus mode: 4-bits data.
  88
  89   *** SD Card Read operation ***
  90   ==============================
  91   [..]
  92     (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
  93         This function support only 512-bytes block length (the block size should be
  94         chosen as 512 bytes).
  95         You can choose either one block read operation or multiple block read operation
  96         by adjusting the "NumberOfBlocks" parameter.
  97
  98     (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
  99         This function support only 512-bytes block length (the block size should be
 100         chosen as 512 bytes).
 101         You can choose either one block read operation or multiple block read operation
 102         by adjusting the "NumberOfBlocks" parameter.
 103         After this, you have to call the function HAL_SD_CheckReadOperation(), to insure
 104         that the read transfer is done correctly in both DMA and SD sides.
 105
 106   *** SD Card Write operation ***
 107   ===============================
 108   [..]
 109     (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
 110         This function support only 512-bytes block length (the block size should be
 111         chosen as 512 bytes).
 112         You can choose either one block read operation or multiple block read operation
 113         by adjusting the "NumberOfBlocks" parameter.
 114
 115     (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
 116         This function support only 512-bytes block length (the block size should be
 117         chosen as 512 byte).
 118         You can choose either one block read operation or multiple block read operation
 119         by adjusting the "NumberOfBlocks" parameter.
 120         After this, you have to call the function HAL_SD_CheckWriteOperation(), to insure
 121         that the write transfer is done correctly in both DMA and SD sides.
 122
 123   *** SD card status ***
 124   ======================
 125   [..]
 126     (+) At any time, you can check the SD Card status and get the SD card state
 127         by using the HAL_SD_GetStatus() function. This function checks first if the
 128         SD card is still connected and then get the internal SD Card transfer state.
 129     (+) You can also get the SD card SD Status register by using the HAL_SD_SendSDStatus()
 130         function.
 131
 132   *** SD HAL driver macros list ***
 133   ==================================
 134   [..]
 135     Below the list of most used macros in SD HAL driver.
 136
 137     (+) __HAL_SD_SDIO_ENABLE : Enable the SD device
 138     (+) __HAL_SD_SDIO_DISABLE : Disable the SD device
 139     (+) __HAL_SD_SDIO_DMA_ENABLE: Enable the SDIO DMA transfer
 140     (+) __HAL_SD_SDIO_DMA_DISABLE: Disable the SDIO DMA transfer
 141     (+) __HAL_SD_SDIO_ENABLE_IT: Enable the SD device interrupt
 142     (+) __HAL_SD_SDIO_DISABLE_IT: Disable the SD device interrupt
 143     (+) __HAL_SD_SDIO_GET_FLAG:Check whether the specified SD flag is set or not
 144     (+) __HAL_SD_SDIO_CLEAR_FLAG: Clear the SD's pending flags
 145
 146     (@) You can refer to the SD HAL driver header file for more useful macros
 147
 148   @endverbatim
 149   ******************************************************************************
 150   * @attention
 151   *
 152   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
 153   *
 154   * Redistribution and use in source and binary forms, with or without modification,
 155   * are permitted provided that the following conditions are met:
 156   *   1. Redistributions of source code must retain the above copyright notice,
 157   *      this list of conditions and the following disclaimer.
 158   *   2. Redistributions in binary form must reproduce the above copyright notice,
 159   *      this list of conditions and the following disclaimer in the documentation
 160   *      and/or other materials provided with the distribution.
 161   *   3. Neither the name of STMicroelectronics nor the names of its contributors
 162   *      may be used to endorse or promote products derived from this software
 163   *      without specific prior written permission.
 164   *
 165   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 166   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 167   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 168   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 169   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 170   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 171   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 172   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 173   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 174   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 175   *
 176   ******************************************************************************
 177   */
 178
 179 /* Includes ------------------------------------------------------------------*/
 180 #include "stm32f2xx_hal.h"
 181 #ifdef HAL_SD_MODULE_ENABLED
 182
 183 /** @addtogroup STM32F2xx_HAL_Driver
 184   * @{
 185   */
 186
 187 /** @addtogroup SD
 188   * @{
 189   */
 190
 191 /* Private typedef -----------------------------------------------------------*/
 192 /* Private define ------------------------------------------------------------*/
 193 /** @addtogroup SD_Private_Defines
 194   * @{
 195   */
 196 /**
 197   * @brief  SDIO Data block size
 198   */
 199 #define DATA_BLOCK_SIZE                  ((uint32_t)(9 << 4))
 200 /**
 201   * @brief  SDIO Static flags, Timeout, FIFO Address
 202   */
 203 #define SDIO_STATIC_FLAGS               ((uint32_t)(SDIO_FLAG_CCRCFAIL | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_CTIMEOUT |\
 204                                                     SDIO_FLAG_DTIMEOUT | SDIO_FLAG_TXUNDERR | SDIO_FLAG_RXOVERR  |\
 205                                                     SDIO_FLAG_CMDREND  | SDIO_FLAG_CMDSENT  | SDIO_FLAG_DATAEND  |\
 206                                                     SDIO_FLAG_DBCKEND))
 207
 208 #define SDIO_CMD0TIMEOUT                ((uint32_t)0x00010000)
 209
 210 /**
 211   * @brief  Mask for errors Card Status R1 (OCR Register)
 212   */
 213 #define SD_OCR_ADDR_OUT_OF_RANGE        ((uint32_t)0x80000000)
 214 #define SD_OCR_ADDR_MISALIGNED          ((uint32_t)0x40000000)
 215 #define SD_OCR_BLOCK_LEN_ERR            ((uint32_t)0x20000000)
 216 #define SD_OCR_ERASE_SEQ_ERR            ((uint32_t)0x10000000)
 217 #define SD_OCR_BAD_ERASE_PARAM          ((uint32_t)0x08000000)
 218 #define SD_OCR_WRITE_PROT_VIOLATION     ((uint32_t)0x04000000)
 219 #define SD_OCR_LOCK_UNLOCK_FAILED       ((uint32_t)0x01000000)
 220 #define SD_OCR_COM_CRC_FAILED           ((uint32_t)0x00800000)
 221 #define SD_OCR_ILLEGAL_CMD              ((uint32_t)0x00400000)
 222 #define SD_OCR_CARD_ECC_FAILED          ((uint32_t)0x00200000)
 223 #define SD_OCR_CC_ERROR                 ((uint32_t)0x00100000)
 224 #define SD_OCR_GENERAL_UNKNOWN_ERROR    ((uint32_t)0x00080000)
 225 #define SD_OCR_STREAM_READ_UNDERRUN     ((uint32_t)0x00040000)
 226 #define SD_OCR_STREAM_WRITE_OVERRUN     ((uint32_t)0x00020000)
 227 #define SD_OCR_CID_CSD_OVERWRITE       ((uint32_t)0x00010000)
 228 #define SD_OCR_WP_ERASE_SKIP            ((uint32_t)0x00008000)
 229 #define SD_OCR_CARD_ECC_DISABLED        ((uint32_t)0x00004000)
 230 #define SD_OCR_ERASE_RESET              ((uint32_t)0x00002000)
 231 #define SD_OCR_AKE_SEQ_ERROR            ((uint32_t)0x00000008)
 232 #define SD_OCR_ERRORBITS                ((uint32_t)0xFDFFE008)
 233
 234 /**
 235   * @brief  Masks for R6 Response
 236   */
 237 #define SD_R6_GENERAL_UNKNOWN_ERROR     ((uint32_t)0x00002000)
 238 #define SD_R6_ILLEGAL_CMD               ((uint32_t)0x00004000)
 239 #define SD_R6_COM_CRC_FAILED            ((uint32_t)0x00008000)
 240
 241 #define SD_VOLTAGE_WINDOW_SD            ((uint32_t)0x80100000)
 242 #define SD_HIGH_CAPACITY                ((uint32_t)0x40000000)
 243 #define SD_STD_CAPACITY                 ((uint32_t)0x00000000)
 244 #define SD_CHECK_PATTERN                ((uint32_t)0x000001AA)
 245
 246 #define SD_MAX_VOLT_TRIAL               ((uint32_t)0x0000FFFF)
 247 #define SD_ALLZERO                      ((uint32_t)0x00000000)
 248
 249 #define SD_WIDE_BUS_SUPPORT             ((uint32_t)0x00040000)
 250 #define SD_SINGLE_BUS_SUPPORT           ((uint32_t)0x00010000)
 251 #define SD_CARD_LOCKED                  ((uint32_t)0x02000000)
 252
 253 #define SD_DATATIMEOUT                  ((uint32_t)0xFFFFFFFF)
 254 #define SD_0TO7BITS                     ((uint32_t)0x000000FF)
 255 #define SD_8TO15BITS                    ((uint32_t)0x0000FF00)
 256 #define SD_16TO23BITS                   ((uint32_t)0x00FF0000)
 257 #define SD_24TO31BITS                   ((uint32_t)0xFF000000)
 258 #define SD_MAX_DATA_LENGTH              ((uint32_t)0x01FFFFFF)
 259
 260 #define SD_HALFFIFO                     ((uint32_t)0x00000008)
 261 #define SD_HALFFIFOBYTES                ((uint32_t)0x00000020)
 262
 263 /**
 264   * @brief  Command Class Supported
 265   */
 266 #define SD_CCCC_LOCK_UNLOCK             ((uint32_t)0x00000080)
 267 #define SD_CCCC_WRITE_PROT              ((uint32_t)0x00000040)
 268 #define SD_CCCC_ERASE                   ((uint32_t)0x00000020)
 269
 270 /**
 271   * @brief  Following commands are SD Card Specific commands.
 272   *         SDIO_APP_CMD should be sent before sending these commands.
 273   */
 274 #define SD_SDIO_SEND_IF_COND            ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
 275
 276 /**
 277   * @}
 278   */
 279
 280 /* Private macro -------------------------------------------------------------*/
 281 /* Private variables ---------------------------------------------------------*/
 282 /* Private function prototypes -----------------------------------------------*/
 283 /** @addtogroup SD_Private_Functions_Prototypes
 284   * @{
 285   */
 286 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
 287 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
 288 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd);
 289 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
 290 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
 291 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
 292 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
 293 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
 294 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
 295 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
 296 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
 297 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
 298 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
 299 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
 300 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
 301 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
 302 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
 303 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
 304 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
 305 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
 306 /**
 307   * @}
 308   */
 309 /* Exported functions --------------------------------------------------------*/
 310 /** @addtogroup SD_Exported_Functions
 311   * @{
 312   */
 313
 314 /** @addtogroup SD_Exported_Functions_Group1
 315  *  @brief   Initialization and de-initialization functions
 316  *
 317 @verbatim
 318   ==============================================================================
 319           ##### Initialization and de-initialization functions #####
 320   ==============================================================================
 321   [..]
 322     This section provides functions allowing to initialize/de-initialize the SD
 323     card device to be ready for use.
 324
 325
 326 @endverbatim
 327   * @{
 328   */
 329
 330 /**
 331   * @brief  Initializes the SD card according to the specified parameters in the
 332             SD_HandleTypeDef and create the associated handle.
 333   * @param  hsd: SD handle
 334   * @param  SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information
 335   * @retval HAL SD error state
 336   */
 337 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
 338 {
 339   __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
 340   SD_InitTypeDef tmpinit;
 341
 342   /* Allocate lock resource and initialize it */
 343   hsd->Lock = HAL_UNLOCKED;
 344   /* Initialize the low level hardware (MSP) */
 345   HAL_SD_MspInit(hsd);
 346
 347   /* Default SDIO peripheral configuration for SD card initialization */
 348   tmpinit.ClockEdge           = SDIO_CLOCK_EDGE_RISING;
 349   tmpinit.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;
 350   tmpinit.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_DISABLE;
 351   tmpinit.BusWide             = SDIO_BUS_WIDE_1B;
 352   tmpinit.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
 353   tmpinit.ClockDiv            = SDIO_INIT_CLK_DIV;
 354
 355   /* Initialize SDIO peripheral interface with default configuration */
 356   SDIO_Init(hsd->Instance, tmpinit);
 357
 358   /* Identify card operating voltage */
 359   errorstate = SD_PowerON(hsd);
 360
 361   if(errorstate != SD_OK)
 362   {
 363     return errorstate;
 364   }
 365
 366   /* Initialize the present SDIO card(s) and put them in idle state */
 367   errorstate = SD_Initialize_Cards(hsd);
 368
 369   if (errorstate != SD_OK)
 370   {
 371     return errorstate;
 372   }
 373
 374   /* Read CSD/CID MSD registers */
 375   errorstate = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
 376
 377   if (errorstate == SD_OK)
 378   {
 379     /* Select the Card */
 380     errorstate = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
 381   }
 382
 383   /* Configure SDIO peripheral interface */
 384   SDIO_Init(hsd->Instance, hsd->Init);
 385
 386   return errorstate;
 387 }
 388
 389 /**
 390   * @brief  De-Initializes the SD card.
 391   * @param  hsd: SD handle
 392   * @retval HAL status
 393   */
 394 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
 395 {
 396
 397   /* Set SD power state to off */
 398   SD_PowerOFF(hsd);
 399
 400   /* De-Initialize the MSP layer */
 401   HAL_SD_MspDeInit(hsd);
 402
 403   return HAL_OK;
 404 }
 405
 406
 407 /**
 408   * @brief  Initializes the SD MSP.
 409   * @param  hsd: SD handle
 410   * @retval None
 411   */
 412 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
 413 {
 414   /* NOTE : This function Should not be modified, when the callback is needed,
 415             the HAL_SD_MspInit could be implemented in the user file
 416    */
 417 }
 418
 419 /**
 420   * @brief  De-Initialize SD MSP.
 421   * @param  hsd: SD handle
 422   * @retval None
 423   */
 424 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
 425 {
 426   /* NOTE : This function Should not be modified, when the callback is needed,
 427             the HAL_SD_MspDeInit could be implemented in the user file
 428    */
 429 }
 430
 431 /**
 432   * @}
 433   */
 434
 435 /** @addtogroup SD_Exported_Functions_Group2
 436  *  @brief   Data transfer functions
 437  *
 438 @verbatim
 439   ==============================================================================
 440                         ##### IO operation functions #####
 441   ==============================================================================
 442   [..]
 443     This subsection provides a set of functions allowing to manage the data
 444     transfer from/to SD card.
 445
 446 @endverbatim
 447   * @{
 448   */
 449
 450 /**
 451   * @brief  Reads block(s) from a specified address in a card. The Data transfer
 452   *         is managed by polling mode.
 453   * @param  hsd: SD handle
 454   * @param  pReadBuffer: pointer to the buffer that will contain the received data
 455   * @param  ReadAddr: Address from where data is to be read
 456   * @param  BlockSize: SD card Data block size
 457   * @note   BlockSize must be 512 bytes.
 458   * @param  NumberOfBlocks: Number of SD blocks to read
 459   * @retval SD Card error state
 460   */
 461 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
 462 {
 463   SDIO_CmdInitTypeDef  sdio_cmdinitstructure;
 464   SDIO_DataInitTypeDef sdio_datainitstructure;
 465   HAL_SD_ErrorTypedef errorstate = SD_OK;
 466   uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
 467
 468   /* Initialize data control register */
 469   hsd->Instance->DCTRL = 0;
 470
 471   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
 472   {
 473     BlockSize = 512;
 474     ReadAddr /= 512;
 475   }
 476
 477   /* Set Block Size for Card */
 478   sdio_cmdinitstructure.Argument         = (uint32_t) BlockSize;
 479   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
 480   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
 481   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
 482   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
 483   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
 484
 485   /* Check for error conditions */
 486   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
 487
 488   if (errorstate != SD_OK)
 489   {
 490     return errorstate;
 491   }
 492
 493   /* Configure the SD DPSM (Data Path State Machine) */
 494   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
 495   sdio_datainitstructure.DataLength    = NumberOfBlocks * BlockSize;
 496   sdio_datainitstructure.DataBlockSize = DATA_BLOCK_SIZE;
 497   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
 498   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
 499   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
 500   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
 501
 502   if(NumberOfBlocks > 1)
 503   {
 504     /* Send CMD18 READ_MULT_BLOCK with argument data address */
 505     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
 506   }
 507   else
 508   {
 509     /* Send CMD17 READ_SINGLE_BLOCK */
 510     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
 511   }
 512
 513   sdio_cmdinitstructure.Argument         = (uint32_t)ReadAddr;
 514   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
 515
 516   /* Read block(s) in polling mode */
 517   if(NumberOfBlocks > 1)
 518   {
 519     /* Check for error conditions */
 520     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
 521
 522     if (errorstate != SD_OK)
 523     {
 524       return errorstate;
 525     }
 526
 527     /* Poll on SDIO flags */
 528     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
 529     {
 530       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
 531       {
 532         /* Read data from SDIO Rx FIFO */
 533         for (count = 0; count < 8; count++)
 534         {
 535           *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
 536         }
 537
 538         tempbuff += 8;
 539       }
 540     }
 541   }
 542   else
 543   {
 544     /* Check for error conditions */
 545     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
 546
 547     if (errorstate != SD_OK)
 548     {
 549       return errorstate;
 550     }
 551
 552     /* In case of single block transfer, no need of stop transfer at all */
 553     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
 554     {
 555       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
 556       {
 557         /* Read data from SDIO Rx FIFO */
 558         for (count = 0; count < 8; count++)
 559         {
 560           *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
 561         }
 562
 563         tempbuff += 8;
 564       }
 565     }
 566   }
 567
 568   /* Send stop transmission command in case of multiblock read */
 569   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
 570   {
 571     if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
 572       (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
 573         (hsd->CardType == HIGH_CAPACITY_SD_CARD))
 574     {
 575       /* Send stop transmission command */
 576       errorstate = HAL_SD_StopTransfer(hsd);
 577     }
 578   }
 579
 580   /* Get error state */
 581   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
 582   {
 583     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
 584
 585     errorstate = SD_DATA_TIMEOUT;
 586
 587     return errorstate;
 588   }
 589   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
 590   {
 591     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
 592
 593     errorstate = SD_DATA_CRC_FAIL;
 594
 595     return errorstate;
 596   }
 597   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
 598   {
 599     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
 600
 601     errorstate = SD_RX_OVERRUN;
 602
 603     return errorstate;
 604   }
 605   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
 606   {
 607     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
 608
 609     errorstate = SD_START_BIT_ERR;
 610
 611     return errorstate;
 612   }
 613   else
 614   {
 615     /* No error flag set */
 616   }
 617
 618   count = SD_DATATIMEOUT;
 619
 620   /* Empty FIFO if there is still any data */
 621   while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
 622   {
 623     *tempbuff = SDIO_ReadFIFO(hsd->Instance);
 624     tempbuff++;
 625     count--;
 626   }
 627
 628   /* Clear all the static flags */
 629   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
 630
 631   return errorstate;
 632 }
 633
 634 /**
 635   * @brief  Allows to write block(s) to a specified address in a card. The Data
 636   *         transfer is managed by polling mode.
 637   * @param  hsd: SD handle
 638   * @param  pWriteBuffer: pointer to the buffer that will contain the data to transmit
 639   * @param  WriteAddr: Address from where data is to be written
 640   * @param  BlockSize: SD card Data block size
 641   * @note   BlockSize must be 512 bytes.
 642   * @param  NumberOfBlocks: Number of SD blocks to write
 643   * @retval SD Card error state
 644   */
 645 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
 646 {
 647   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
 648   SDIO_DataInitTypeDef sdio_datainitstructure;
 649   HAL_SD_ErrorTypedef errorstate = SD_OK;
 650   uint32_t totalnumberofbytes = 0, bytestransferred = 0, count = 0, restwords = 0;
 651   uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
 652   uint8_t cardstate  = 0;
 653
 654   /* Initialize data control register */
 655   hsd->Instance->DCTRL = 0;
 656
 657   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
 658   {
 659     BlockSize = 512;
 660     WriteAddr /= 512;
 661   }
 662
 663   /* Set Block Size for Card */
 664   sdio_cmdinitstructure.Argument         = (uint32_t)BlockSize;
 665   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
 666   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
 667   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
 668   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
 669   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
 670
 671   /* Check for error conditions */
 672   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
 673
 674   if (errorstate != SD_OK)
 675   {
 676     return errorstate;
 677   }
 678
 679   if(NumberOfBlocks > 1)
 680   {
 681     /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
 682     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
 683   }
 684   else
 685   {
 686     /* Send CMD24 WRITE_SINGLE_BLOCK */
 687     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
 688   }
 689
 690   sdio_cmdinitstructure.Argument         = (uint32_t)WriteAddr;
 691   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
 692
 693   /* Check for error conditions */
 694   if(NumberOfBlocks > 1)
 695   {
 696     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
 697   }
 698   else
 699   {
 700     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
 701   }
 702
 703   if (errorstate != SD_OK)
 704   {
 705     return errorstate;
 706   }
 707
 708   /* Set total number of bytes to write */
 709   totalnumberofbytes = NumberOfBlocks * BlockSize;
 710
 711   /* Configure the SD DPSM (Data Path State Machine) */
 712   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
 713   sdio_datainitstructure.DataLength    = NumberOfBlocks * BlockSize;
 714   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
 715   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
 716   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
 717   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
 718   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
 719
 720   /* Write block(s) in polling mode */
 721   if(NumberOfBlocks > 1)
 722   {
 723     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
 724     {
 725       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
 726       {
 727         if ((totalnumberofbytes - bytestransferred) < 32)
 728         {
 729           restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes -  bytestransferred) / 4 + 1);
 730
 731           /* Write data to SDIO Tx FIFO */
 732           for (count = 0; count < restwords; count++)
 733           {
 734             SDIO_WriteFIFO(hsd->Instance, tempbuff);
 735             tempbuff++;
 736             bytestransferred += 4;
 737           }
 738         }
 739         else
 740         {
 741           /* Write data to SDIO Tx FIFO */
 742           for (count = 0; count < 8; count++)
 743           {
 744             SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
 745           }
 746
 747           tempbuff += 8;
 748           bytestransferred += 32;
 749         }
 750       }
 751     }
 752   }
 753   else
 754   {
 755     /* In case of single data block transfer no need of stop command at all */
 756     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
 757     {
 758       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
 759       {
 760         if ((totalnumberofbytes - bytestransferred) < 32)
 761         {
 762           restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes -  bytestransferred) / 4 + 1);
 763
 764           /* Write data to SDIO Tx FIFO */
 765           for (count = 0; count < restwords; count++)
 766           {
 767             SDIO_WriteFIFO(hsd->Instance, tempbuff);
 768             tempbuff++;
 769             bytestransferred += 4;
 770           }
 771         }
 772         else
 773         {
 774           /* Write data to SDIO Tx FIFO */
 775           for (count = 0; count < 8; count++)
 776           {
 777             SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
 778           }
 779
 780           tempbuff += 8;
 781           bytestransferred += 32;
 782         }
 783       }
 784     }
 785   }
 786
 787   /* Send stop transmission command in case of multiblock write */
 788   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
 789   {
 790     if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
 791       (hsd->CardType == HIGH_CAPACITY_SD_CARD))
 792     {
 793       /* Send stop transmission command */
 794       errorstate = HAL_SD_StopTransfer(hsd);
 795     }
 796   }
 797
 798   /* Get error state */
 799   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
 800   {
 801     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
 802
 803     errorstate = SD_DATA_TIMEOUT;
 804
 805     return errorstate;
 806   }
 807   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
 808   {
 809     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
 810
 811     errorstate = SD_DATA_CRC_FAIL;
 812
 813     return errorstate;
 814   }
 815   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
 816   {
 817     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
 818
 819     errorstate = SD_TX_UNDERRUN;
 820
 821     return errorstate;
 822   }
 823   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
 824   {
 825     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
 826
 827     errorstate = SD_START_BIT_ERR;
 828
 829     return errorstate;
 830   }
 831   else
 832   {
 833     /* No error flag set */
 834   }
 835
 836   /* Clear all the static flags */
 837   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
 838
 839   /* Wait till the card is in programming state */
 840   errorstate = SD_IsCardProgramming(hsd, &cardstate);
 841
 842   while ((errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
 843   {
 844     errorstate = SD_IsCardProgramming(hsd, &cardstate);
 845   }
 846
 847   return errorstate;
 848 }
 849
 850 /**
 851   * @brief  Reads block(s) from a specified address in a card. The Data transfer
 852   *         is managed by DMA mode.
 853   * @note   This API should be followed by the function HAL_SD_CheckReadOperation()
 854   *         to check the completion of the read process
 855   * @param  hsd: SD handle
 856   * @param  pReadBuffer: Pointer to the buffer that will contain the received data
 857   * @param  ReadAddr: Address from where data is to be read
 858   * @param  BlockSize: SD card Data block size
 859   * @note   BlockSize must be 512 bytes.
 860   * @param  NumberOfBlocks: Number of blocks to read.
 861   * @retval SD Card error state
 862   */
 863 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
 864 {
 865   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
 866   SDIO_DataInitTypeDef sdio_datainitstructure;
 867   HAL_SD_ErrorTypedef errorstate = SD_OK;
 868
 869   /* Initialize data control register */
 870   hsd->Instance->DCTRL = 0;
 871
 872   /* Initialize handle flags */
 873   hsd->SdTransferCplt  = 0;
 874   hsd->DmaTransferCplt = 0;
 875   hsd->SdTransferErr   = SD_OK;
 876
 877   /* Initialize SD Read operation */
 878   if(NumberOfBlocks > 1)
 879   {
 880     hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
 881   }
 882   else
 883   {
 884     hsd->SdOperation = SD_READ_SINGLE_BLOCK;
 885   }
 886
 887   /* Enable transfer interrupts */
 888   __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
 889                                 SDIO_IT_DTIMEOUT |\
 890                                 SDIO_IT_DATAEND  |\
 891                                 SDIO_IT_RXOVERR  |\
 892                                 SDIO_IT_STBITERR));
 893
 894   /* Enable SDIO DMA transfer */
 895   __HAL_SD_SDIO_DMA_ENABLE();
 896
 897   /* Configure DMA user callbacks */
 898   hsd->hdmarx->XferCpltCallback  = SD_DMA_RxCplt;
 899   hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
 900
 901   /* Enable the DMA Stream */
 902   HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks)/4);
 903
 904   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
 905   {
 906     BlockSize = 512;
 907     ReadAddr /= 512;
 908   }
 909
 910   /* Set Block Size for Card */
 911   sdio_cmdinitstructure.Argument         = (uint32_t)BlockSize;
 912   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
 913   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
 914   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
 915   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
 916   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
 917
 918   /* Check for error conditions */
 919   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
 920
 921   if (errorstate != SD_OK)
 922   {
 923     return errorstate;
 924   }
 925
 926   /* Configure the SD DPSM (Data Path State Machine) */
 927   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
 928   sdio_datainitstructure.DataLength    = BlockSize * NumberOfBlocks;
 929   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
 930   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
 931   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
 932   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
 933   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
 934
 935   /* Check number of blocks command */
 936   if(NumberOfBlocks > 1)
 937   {
 938     /* Send CMD18 READ_MULT_BLOCK with argument data address */
 939     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
 940   }
 941   else
 942   {
 943     /* Send CMD17 READ_SINGLE_BLOCK */
 944     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
 945   }
 946
 947   sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
 948   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
 949
 950   /* Check for error conditions */
 951   if(NumberOfBlocks > 1)
 952   {
 953     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
 954   }
 955   else
 956   {
 957     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
 958   }
 959
 960   /* Update the SD transfer error in SD handle */
 961   hsd->SdTransferErr = errorstate;
 962
 963   return errorstate;
 964 }
 965
 966
 967 /**
 968   * @brief  Writes block(s) to a specified address in a card. The Data transfer
 969   *         is managed by DMA mode.
 970   * @note   This API should be followed by the function HAL_SD_CheckWriteOperation()
 971   *         to check the completion of the write process (by SD current status polling).
 972   * @param  hsd: SD handle
 973   * @param  pWriteBuffer: pointer to the buffer that will contain the data to transmit
 974   * @param  WriteAddr: Address from where data is to be read
 975   * @param  BlockSize: the SD card Data block size
 976   * @note   BlockSize must be 512 bytes.
 977   * @param  NumberOfBlocks: Number of blocks to write
 978   * @retval SD Card error state
 979   */
 980 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
 981 {
 982   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
 983   SDIO_DataInitTypeDef sdio_datainitstructure;
 984   HAL_SD_ErrorTypedef errorstate = SD_OK;
 985
 986   /* Initialize data control register */
 987   hsd->Instance->DCTRL = 0;
 988
 989   /* Initialize handle flags */
 990   hsd->SdTransferCplt  = 0;
 991   hsd->DmaTransferCplt = 0;
 992   hsd->SdTransferErr   = SD_OK;
 993
 994   /* Initialize SD Write operation */
 995   if(NumberOfBlocks > 1)
 996   {
 997     hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
 998   }
 999   else
1000   {
1001     hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
1002   }
1003
1004   /* Enable transfer interrupts */
1005   __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
1006                                 SDIO_IT_DTIMEOUT |\
1007                                 SDIO_IT_DATAEND  |\
1008                                 SDIO_IT_TXUNDERR |\
1009                                 SDIO_IT_STBITERR));
1010
1011   /* Configure DMA user callbacks */
1012   hsd->hdmatx->XferCpltCallback  = SD_DMA_TxCplt;
1013   hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
1014
1015   /* Enable the DMA Stream */
1016   HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BlockSize * NumberOfBlocks)/4);
1017
1018   /* Enable SDIO DMA transfer */
1019   __HAL_SD_SDIO_DMA_ENABLE();
1020
1021   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1022   {
1023     BlockSize = 512;
1024     WriteAddr /= 512;
1025   }
1026
1027   /* Set Block Size for Card */
1028   sdio_cmdinitstructure.Argument         = (uint32_t)BlockSize;
1029   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
1030   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1031   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1032   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1033   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1034
1035   /* Check for error conditions */
1036   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1037
1038   if (errorstate != SD_OK)
1039   {
1040     return errorstate;
1041   }
1042
1043   /* Check number of blocks command */
1044   if(NumberOfBlocks <= 1)
1045   {
1046     /* Send CMD24 WRITE_SINGLE_BLOCK */
1047     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
1048   }
1049   else
1050   {
1051     /* MM: Prepare for write */
1052     /* Set Block Size for Card */
1053     sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
1054     sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
1055     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1056     errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
1057     if (errorstate != SD_OK)
1058     {
1059       return errorstate;
1060     }
1061     sdio_cmdinitstructure.Argument         = (uint32_t)NumberOfBlocks;
1062     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCK_COUNT;
1063     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1064     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCK_COUNT);
1065     if (errorstate != SD_OK)
1066     {
1067       return errorstate;
1068     }
1069
1070     /* /MM */
1071
1072     /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
1073     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
1074   }
1075
1076   sdio_cmdinitstructure.Argument         = (uint32_t)WriteAddr;
1077   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1078
1079   /* Check for error conditions */
1080   if(NumberOfBlocks > 1)
1081   {
1082     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
1083   }
1084   else
1085   {
1086     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
1087   }
1088
1089   if (errorstate != SD_OK)
1090   {
1091     return errorstate;
1092   }
1093
1094   /* Configure the SD DPSM (Data Path State Machine) */
1095   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
1096   sdio_datainitstructure.DataLength    = BlockSize * NumberOfBlocks;
1097   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1098   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
1099   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1100   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
1101   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1102
1103   hsd->SdTransferErr = errorstate;
1104
1105   return errorstate;
1106 }
1107
1108 /**
1109   * @brief  This function waits until the SD DMA data read transfer is finished.
1110   *         This API should be called after HAL_SD_ReadBlocks_DMA() function
1111   *         to insure that all data sent by the card is already transferred by the
1112   *         DMA controller.
1113   * @param  hsd: SD handle
1114   * @param  Timeout: Timeout duration
1115   * @retval SD Card error state
1116   */
1117 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1118 {
1119   HAL_SD_ErrorTypedef errorstate = SD_OK;
1120   uint32_t timeout = Timeout;
1121   uint32_t tmp1, tmp2;
1122   HAL_SD_ErrorTypedef tmp3;
1123
1124   /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1125   tmp1 = hsd->DmaTransferCplt;
1126   tmp2 = hsd->SdTransferCplt;
1127   tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1128
1129   while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1130   {
1131     tmp1 = hsd->DmaTransferCplt;
1132     tmp2 = hsd->SdTransferCplt;
1133     tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1134     timeout--;
1135   }
1136
1137   timeout = Timeout;
1138
1139   /* Wait until the Rx transfer is no longer active. IE. fifo is empty.
1140 Once FIFO is empty, the DMA will have finished and DmaTransferCplt should
1141 be true */
1142   while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXACT)) && (timeout > 0))
1143   {
1144     timeout--;
1145   }
1146
1147   /* Send stop command in multiblock read */
1148   if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
1149   {
1150     errorstate = HAL_SD_StopTransfer(hsd);
1151   }
1152
1153   if ((timeout == 0) && (errorstate == SD_OK))
1154   {
1155     errorstate = SD_DATA_TIMEOUT;
1156   }
1157
1158   /* Clear all the static flags */
1159   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1160
1161   /* Return error state */
1162   if (hsd->SdTransferErr != SD_OK)
1163   {
1164     return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1165   }
1166
1167   return errorstate;
1168 }
1169
1170 /**
1171   * @brief  This function waits until the SD DMA data write transfer is finished.
1172   *         This API should be called after HAL_SD_WriteBlocks_DMA() function
1173   *         to insure that all data sent by the card is already transferred by the
1174   *         DMA controller.
1175   * @param  hsd: SD handle
1176   * @param  Timeout: Timeout duration
1177   * @retval SD Card error state
1178   */
1179 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1180 {
1181   HAL_SD_ErrorTypedef errorstate = SD_OK;
1182   uint32_t timeout = Timeout;
1183   uint32_t tmp1, tmp2;
1184   HAL_SD_ErrorTypedef tmp3;
1185
1186   /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1187   tmp1 = hsd->DmaTransferCplt;
1188   tmp2 = hsd->SdTransferCplt;
1189   tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1190
1191   while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1192   {
1193     tmp1 = hsd->DmaTransferCplt;
1194     tmp2 = hsd->SdTransferCplt;
1195     tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1196     timeout--;
1197   }
1198
1199   timeout = Timeout;
1200
1201   /* Wait until the Tx transfer is no longer active */
1202   while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXACT))  && (timeout > 0))
1203   {
1204     timeout--;
1205   }
1206
1207   /* Send stop command in multiblock write */
1208   if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
1209   {
1210     errorstate = HAL_SD_StopTransfer(hsd);
1211   }
1212
1213   if ((timeout == 0) && (errorstate == SD_OK))
1214   {
1215     errorstate = SD_DATA_TIMEOUT;
1216   }
1217
1218   /* Clear all the static flags */
1219   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1220
1221   /* Return error state */
1222   if (hsd->SdTransferErr != SD_OK)
1223   {
1224     return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1225   }
1226
1227   /* Wait until write is complete */
1228   while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
1229   {
1230   }
1231
1232   return errorstate;
1233 }
1234
1235 /**
1236   * @brief  Erases the specified memory area of the given SD card.
1237   * @param  hsd: SD handle
1238   * @param  startaddr: Start byte address
1239   * @param  endaddr: End byte address
1240   * @retval SD Card error state
1241   */
1242 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
1243 {
1244   HAL_SD_ErrorTypedef errorstate = SD_OK;
1245   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1246
1247   uint32_t delay         = 0;
1248   __IO uint32_t maxdelay = 0;
1249   uint8_t cardstate      = 0;
1250
1251   /* Check if the card command class supports erase command */
1252   if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
1253   {
1254     errorstate = SD_REQUEST_NOT_APPLICABLE;
1255
1256     return errorstate;
1257   }
1258
1259   /* Get max delay value */
1260   maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
1261
1262   if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1263   {
1264     errorstate = SD_LOCK_UNLOCK_FAILED;
1265
1266     return errorstate;
1267   }
1268
1269   /* Get start and end block for high capacity cards */
1270   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1271   {
1272     startaddr /= 512;
1273     endaddr   /= 512;
1274   }
1275
1276   /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1277   if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1278     (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1279   {
1280     /* Send CMD32 SD_ERASE_GRP_START with argument as addr  */
1281     sdio_cmdinitstructure.Argument         =(uint32_t)startaddr;
1282     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_ERASE_GRP_START;
1283     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1284     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1285     sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1286     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1287
1288     /* Check for error conditions */
1289     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
1290
1291     if (errorstate != SD_OK)
1292     {
1293       return errorstate;
1294     }
1295
1296     /* Send CMD33 SD_ERASE_GRP_END with argument as addr  */
1297     sdio_cmdinitstructure.Argument         = (uint32_t)endaddr;
1298     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_ERASE_GRP_END;
1299     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1300
1301     /* Check for error conditions */
1302     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
1303
1304     if (errorstate != SD_OK)
1305     {
1306       return errorstate;
1307     }
1308   }
1309
1310   /* Send CMD38 ERASE */
1311   sdio_cmdinitstructure.Argument         = 0;
1312   sdio_cmdinitstructure.CmdIndex         = SD_CMD_ERASE;
1313   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1314
1315   /* Check for error conditions */
1316   errorstate = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
1317
1318   if (errorstate != SD_OK)
1319   {
1320     return errorstate;
1321   }
1322
1323   for (; delay < maxdelay; delay++)
1324   {
1325   }
1326
1327   /* Wait until the card is in programming state */
1328   errorstate = SD_IsCardProgramming(hsd, &cardstate);
1329
1330   delay = SD_DATATIMEOUT;
1331
1332   while ((delay > 0) && (errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
1333   {
1334     errorstate = SD_IsCardProgramming(hsd, &cardstate);
1335     delay--;
1336   }
1337
1338   return errorstate;
1339 }
1340
1341 /**
1342   * @brief  This function handles SD card interrupt request.
1343   * @param  hsd: SD handle
1344   * @retval None
1345   */
1346 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1347 {
1348   /* Check for SDIO interrupt flags */
1349   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DATAEND))
1350   {
1351     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_IT_DATAEND);
1352
1353     /* SD transfer is complete */
1354     hsd->SdTransferCplt = 1;
1355
1356     /* No transfer error */
1357     hsd->SdTransferErr  = SD_OK;
1358
1359     HAL_SD_XferCpltCallback(hsd);
1360   }
1361   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DCRCFAIL))
1362   {
1363     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1364
1365     hsd->SdTransferErr = SD_DATA_CRC_FAIL;
1366
1367     HAL_SD_XferErrorCallback(hsd);
1368
1369   }
1370   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DTIMEOUT))
1371   {
1372     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1373
1374     hsd->SdTransferErr = SD_DATA_TIMEOUT;
1375
1376     HAL_SD_XferErrorCallback(hsd);
1377   }
1378   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_RXOVERR))
1379   {
1380     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1381
1382     hsd->SdTransferErr = SD_RX_OVERRUN;
1383
1384     HAL_SD_XferErrorCallback(hsd);
1385   }
1386   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_TXUNDERR))
1387   {
1388     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
1389
1390     hsd->SdTransferErr = SD_TX_UNDERRUN;
1391
1392     HAL_SD_XferErrorCallback(hsd);
1393   }
1394   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_STBITERR))
1395   {
1396     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1397
1398     hsd->SdTransferErr = SD_START_BIT_ERR;
1399
1400     HAL_SD_XferErrorCallback(hsd);
1401   }
1402   else
1403   {
1404     /* No error flag set */
1405   }
1406
1407   /* Disable all SDIO peripheral interrupt sources */
1408   __HAL_SD_SDIO_DISABLE_IT(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND  |\
1409                                 SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |\
1410                                 SDIO_IT_RXOVERR  | SDIO_IT_STBITERR);
1411 }
1412
1413
1414 /**
1415   * @brief  SD end of transfer callback.
1416   * @param  hsd: SD handle
1417   * @retval None
1418   */
1419 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
1420 {
1421   /* NOTE : This function Should not be modified, when the callback is needed,
1422             the HAL_SD_XferCpltCallback could be implemented in the user file
1423    */
1424 }
1425
1426 /**
1427   * @brief  SD Transfer Error callback.
1428   * @param  hsd: SD handle
1429   * @retval None
1430   */
1431 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
1432 {
1433   /* NOTE : This function Should not be modified, when the callback is needed,
1434             the HAL_SD_XferErrorCallback could be implemented in the user file
1435    */
1436 }
1437
1438 /**
1439   * @brief  SD Transfer complete Rx callback in non blocking mode.
1440   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1441   *                the configuration information for the specified DMA module.
1442   * @retval None
1443   */
1444 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
1445 {
1446   /* NOTE : This function Should not be modified, when the callback is needed,
1447             the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
1448    */
1449 }
1450
1451 /**
1452   * @brief  SD DMA transfer complete Rx error callback.
1453   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1454   *                the configuration information for the specified DMA module.
1455   * @retval None
1456   */
1457 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
1458 {
1459   /* NOTE : This function Should not be modified, when the callback is needed,
1460             the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
1461    */
1462 }
1463
1464 /**
1465   * @brief  SD Transfer complete Tx callback in non blocking mode.
1466   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1467   *                the configuration information for the specified DMA module.
1468   * @retval None
1469   */
1470 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
1471 {
1472   /* NOTE : This function Should not be modified, when the callback is needed,
1473             the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
1474    */
1475 }
1476
1477 /**
1478   * @brief  SD DMA transfer complete error Tx callback.
1479   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1480   *                the configuration information for the specified DMA module.
1481   * @retval None
1482   */
1483 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
1484 {
1485   /* NOTE : This function Should not be modified, when the callback is needed,
1486             the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
1487    */
1488 }
1489
1490 /**
1491   * @}
1492   */
1493
1494 /** @addtogroup SD_Exported_Functions_Group3
1495  *  @brief   management functions
1496  *
1497 @verbatim
1498   ==============================================================================
1499                       ##### Peripheral Control functions #####
1500   ==============================================================================
1501   [..]
1502     This subsection provides a set of functions allowing to control the SD card
1503     operations.
1504
1505 @endverbatim
1506   * @{
1507   */
1508
1509 /**
1510   * @brief  Returns information about specific card.
1511   * @param  hsd: SD handle
1512   * @param  pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
1513   *         contains all SD cardinformation
1514   * @retval SD Card error state
1515   */
1516 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
1517 {
1518   HAL_SD_ErrorTypedef errorstate = SD_OK;
1519   uint32_t tmp = 0;
1520
1521   pCardInfo->CardType = (uint8_t)(hsd->CardType);
1522   pCardInfo->RCA      = (uint16_t)(hsd->RCA);
1523
1524   /* Byte 0 */
1525   tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
1526   pCardInfo->SD_csd.CSDStruct      = (uint8_t)((tmp & 0xC0) >> 6);
1527   pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
1528   pCardInfo->SD_csd.Reserved1      = tmp & 0x03;
1529
1530   /* Byte 1 */
1531   tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
1532   pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
1533
1534   /* Byte 2 */
1535   tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
1536   pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
1537
1538   /* Byte 3 */
1539   tmp = hsd->CSD[0] & 0x000000FF;
1540   pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
1541
1542   /* Byte 4 */
1543   tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
1544   pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
1545
1546   /* Byte 5 */
1547   tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
1548   pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
1549   pCardInfo->SD_csd.RdBlockLen       = (uint8_t)(tmp & 0x0F);
1550
1551   /* Byte 6 */
1552   tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
1553   pCardInfo->SD_csd.PartBlockRead   = (uint8_t)((tmp & 0x80) >> 7);
1554   pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
1555   pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
1556   pCardInfo->SD_csd.DSRImpl         = (uint8_t)((tmp & 0x10) >> 4);
1557   pCardInfo->SD_csd.Reserved2       = 0; /*!< Reserved */
1558
1559   if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
1560   {
1561     pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
1562
1563     /* Byte 7 */
1564     tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1565     pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
1566
1567     /* Byte 8 */
1568     tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1569     pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
1570
1571     pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
1572     pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
1573
1574     /* Byte 9 */
1575     tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1576     pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
1577     pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
1578     pCardInfo->SD_csd.DeviceSizeMul      = (tmp & 0x03) << 1;
1579     /* Byte 10 */
1580     tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1581     pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
1582
1583     pCardInfo->CardCapacity  = (pCardInfo->SD_csd.DeviceSize + 1) ;
1584     pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
1585     pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
1586     pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
1587   }
1588   else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1589   {
1590     /* Byte 7 */
1591     tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1592     pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
1593
1594     /* Byte 8 */
1595     tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1596
1597     pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
1598
1599     /* Byte 9 */
1600     tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1601
1602     pCardInfo->SD_csd.DeviceSize |= (tmp);
1603
1604     /* Byte 10 */
1605     tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1606
1607     pCardInfo->CardCapacity = (uint64_t)((((uint64_t)pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024);
1608     pCardInfo->CardBlockSize = 512;
1609   }
1610   else
1611   {
1612     /* Not supported card type */
1613     errorstate = SD_ERROR;
1614   }
1615
1616   pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
1617   pCardInfo->SD_csd.EraseGrMul  = (tmp & 0x3F) << 1;
1618
1619   /* Byte 11 */
1620   tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
1621   pCardInfo->SD_csd.EraseGrMul     |= (tmp & 0x80) >> 7;
1622   pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
1623
1624   /* Byte 12 */
1625   tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
1626   pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
1627   pCardInfo->SD_csd.ManDeflECC        = (tmp & 0x60) >> 5;
1628   pCardInfo->SD_csd.WrSpeedFact       = (tmp & 0x1C) >> 2;
1629   pCardInfo->SD_csd.MaxWrBlockLen     = (tmp & 0x03) << 2;
1630
1631   /* Byte 13 */
1632   tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
1633   pCardInfo->SD_csd.MaxWrBlockLen      |= (tmp & 0xC0) >> 6;
1634   pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
1635   pCardInfo->SD_csd.Reserved3           = 0;
1636   pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
1637
1638   /* Byte 14 */
1639   tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
1640   pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
1641   pCardInfo->SD_csd.CopyFlag         = (tmp & 0x40) >> 6;
1642   pCardInfo->SD_csd.PermWrProtect    = (tmp & 0x20) >> 5;
1643   pCardInfo->SD_csd.TempWrProtect    = (tmp & 0x10) >> 4;
1644   pCardInfo->SD_csd.FileFormat       = (tmp & 0x0C) >> 2;
1645   pCardInfo->SD_csd.ECC              = (tmp & 0x03);
1646
1647   /* Byte 15 */
1648   tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
1649   pCardInfo->SD_csd.CSD_CRC   = (tmp & 0xFE) >> 1;
1650   pCardInfo->SD_csd.Reserved4 = 1;
1651
1652   /* Byte 0 */
1653   tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
1654   pCardInfo->SD_cid.ManufacturerID = tmp;
1655
1656   /* Byte 1 */
1657   tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
1658   pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
1659
1660   /* Byte 2 */
1661   tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
1662   pCardInfo->SD_cid.OEM_AppliID |= tmp;
1663
1664   /* Byte 3 */
1665   tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
1666   pCardInfo->SD_cid.ProdName1 = tmp << 24;
1667
1668   /* Byte 4 */
1669   tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
1670   pCardInfo->SD_cid.ProdName1 |= tmp << 16;
1671
1672   /* Byte 5 */
1673   tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
1674   pCardInfo->SD_cid.ProdName1 |= tmp << 8;
1675
1676   /* Byte 6 */
1677   tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
1678   pCardInfo->SD_cid.ProdName1 |= tmp;
1679
1680   /* Byte 7 */
1681   tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
1682   pCardInfo->SD_cid.ProdName2 = tmp;
1683
1684   /* Byte 8 */
1685   tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
1686   pCardInfo->SD_cid.ProdRev = tmp;
1687
1688   /* Byte 9 */
1689   tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
1690   pCardInfo->SD_cid.ProdSN = tmp << 24;
1691
1692   /* Byte 10 */
1693   tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
1694   pCardInfo->SD_cid.ProdSN |= tmp << 16;
1695
1696   /* Byte 11 */
1697   tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
1698   pCardInfo->SD_cid.ProdSN |= tmp << 8;
1699
1700   /* Byte 12 */
1701   tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
1702   pCardInfo->SD_cid.ProdSN |= tmp;
1703
1704   /* Byte 13 */
1705   tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
1706   pCardInfo->SD_cid.Reserved1   |= (tmp & 0xF0) >> 4;
1707   pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
1708
1709   /* Byte 14 */
1710   tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
1711   pCardInfo->SD_cid.ManufactDate |= tmp;
1712
1713   /* Byte 15 */
1714   tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
1715   pCardInfo->SD_cid.CID_CRC   = (tmp & 0xFE) >> 1;
1716   pCardInfo->SD_cid.Reserved2 = 1;
1717
1718   return errorstate;
1719 }
1720
1721 /**
1722   * @brief  Enables wide bus operation for the requested card if supported by
1723   *         card.
1724   * @param  hsd: SD handle
1725   * @param  WideMode: Specifies the SD card wide bus mode
1726   *          This parameter can be one of the following values:
1727   *            @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
1728   *            @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
1729   *            @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
1730   * @retval SD Card error state
1731   */
1732 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
1733 {
1734   HAL_SD_ErrorTypedef errorstate = SD_OK;
1735   SDIO_InitTypeDef tmpinit;
1736
1737   /* MMC Card does not support this feature */
1738   if (hsd->CardType == MULTIMEDIA_CARD)
1739   {
1740     errorstate = SD_UNSUPPORTED_FEATURE;
1741
1742     return errorstate;
1743   }
1744   else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1745     (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1746   {
1747     if (WideMode == SDIO_BUS_WIDE_8B)
1748     {
1749       errorstate = SD_UNSUPPORTED_FEATURE;
1750     }
1751     else if (WideMode == SDIO_BUS_WIDE_4B)
1752     {
1753       errorstate = SD_WideBus_Enable(hsd);
1754     }
1755     else if (WideMode == SDIO_BUS_WIDE_1B)
1756     {
1757       errorstate = SD_WideBus_Disable(hsd);
1758     }
1759     else
1760     {
1761       /* WideMode is not a valid argument*/
1762       errorstate = SD_INVALID_PARAMETER;
1763     }
1764
1765     if (errorstate == SD_OK)
1766     {
1767       /* Configure the SDIO peripheral */
1768       tmpinit.ClockEdge           = hsd->Init.ClockEdge;
1769       tmpinit.ClockBypass         = hsd->Init.ClockBypass;
1770       tmpinit.ClockPowerSave      = hsd->Init.ClockPowerSave;
1771       tmpinit.BusWide             = WideMode;
1772       tmpinit.HardwareFlowControl = hsd->Init.HardwareFlowControl;
1773       tmpinit.ClockDiv            = hsd->Init.ClockDiv;
1774       SDIO_Init(hsd->Instance, tmpinit);
1775     }
1776   }
1777
1778   return errorstate;
1779 }
1780
1781 /**
1782   * @brief  Aborts an ongoing data transfer.
1783   * @param  hsd: SD handle
1784   * @retval SD Card error state
1785   */
1786 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
1787 {
1788   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1789   HAL_SD_ErrorTypedef errorstate = SD_OK;
1790
1791   /* Send CMD12 STOP_TRANSMISSION  */
1792   sdio_cmdinitstructure.Argument         = 0;
1793   sdio_cmdinitstructure.CmdIndex         = SD_CMD_STOP_TRANSMISSION;
1794   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1795   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1796   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1797   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1798
1799   /* Check for error conditions */
1800   errorstate = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
1801
1802   return errorstate;
1803 }
1804
1805 /**
1806   * @brief  Switches the SD card to High Speed mode.
1807   *         This API must be used after "Transfer State"
1808   * @note   This operation should be followed by the configuration
1809   *         of PLL to have SDIOCK clock between 67 and 75 MHz
1810   * @param  hsd: SD handle
1811   * @retval SD Card error state
1812   */
1813 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
1814 {
1815   HAL_SD_ErrorTypedef errorstate = SD_OK;
1816   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1817   SDIO_DataInitTypeDef sdio_datainitstructure;
1818
1819   uint8_t SD_hs[64]  = {0};
1820   uint32_t SD_scr[2] = {0, 0};
1821   uint32_t SD_SPEC   = 0 ;
1822   uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
1823
1824   /* Initialize the Data control register */
1825   hsd->Instance->DCTRL = 0;
1826
1827   /* Get SCR Register */
1828   errorstate = SD_FindSCR(hsd, SD_scr);
1829
1830   if (errorstate != SD_OK)
1831   {
1832     return errorstate;
1833   }
1834
1835   /* Test the Version supported by the card*/
1836   SD_SPEC = (SD_scr[1]  & 0x01000000) | (SD_scr[1]  & 0x02000000);
1837
1838   if (SD_SPEC != SD_ALLZERO)
1839   {
1840     /* Set Block Size for Card */
1841     sdio_cmdinitstructure.Argument         = (uint32_t)64;
1842     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
1843     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1844     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1845     sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1846     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1847
1848     /* Check for error conditions */
1849     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1850
1851     if (errorstate != SD_OK)
1852     {
1853       return errorstate;
1854     }
1855
1856     /* Configure the SD DPSM (Data Path State Machine) */
1857     sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
1858     sdio_datainitstructure.DataLength    = 64;
1859     sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
1860     sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
1861     sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1862     sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
1863     SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1864
1865     /* Send CMD6 switch mode */
1866     sdio_cmdinitstructure.Argument         = 0x80FFFF01;
1867     sdio_cmdinitstructure.CmdIndex         = SD_CMD_HS_SWITCH;
1868     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1869
1870     /* Check for error conditions */
1871     errorstate = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
1872
1873     if (errorstate != SD_OK)
1874     {
1875       return errorstate;
1876     }
1877
1878     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
1879     {
1880       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
1881       {
1882         for (count = 0; count < 8; count++)
1883         {
1884           *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
1885         }
1886
1887         tempbuff += 8;
1888       }
1889     }
1890
1891     if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
1892     {
1893       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1894
1895       errorstate = SD_DATA_TIMEOUT;
1896
1897       return errorstate;
1898     }
1899     else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
1900     {
1901       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1902
1903       errorstate = SD_DATA_CRC_FAIL;
1904
1905       return errorstate;
1906     }
1907     else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
1908     {
1909       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1910
1911       errorstate = SD_RX_OVERRUN;
1912
1913       return errorstate;
1914     }
1915     else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
1916     {
1917       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1918
1919       errorstate = SD_START_BIT_ERR;
1920
1921       return errorstate;
1922     }
1923     else
1924     {
1925       /* No error flag set */
1926     }
1927
1928     count = SD_DATATIMEOUT;
1929
1930     while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
1931     {
1932       *tempbuff = SDIO_ReadFIFO(hsd->Instance);
1933       tempbuff++;
1934       count--;
1935     }
1936
1937     /* Clear all the static flags */
1938     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1939
1940     /* Test if the switch mode HS is ok */
1941     if ((SD_hs[13]& 2) != 2)
1942     {
1943       errorstate = SD_UNSUPPORTED_FEATURE;
1944     }
1945   }
1946
1947   return errorstate;
1948 }
1949
1950 /**
1951   * @}
1952   */
1953
1954 /** @addtogroup SD_Exported_Functions_Group4
1955  *  @brief   Peripheral State functions
1956  *
1957 @verbatim
1958   ==============================================================================
1959                       ##### Peripheral State functions #####
1960   ==============================================================================
1961   [..]
1962     This subsection permits to get in runtime the status of the peripheral
1963     and the data flow.
1964
1965 @endverbatim
1966   * @{
1967   */
1968
1969 /**
1970   * @brief  Returns the current SD card's status.
1971   * @param  hsd: SD handle
1972   * @param  pSDstatus: Pointer to the buffer that will contain the SD card status
1973   *         SD Status register)
1974   * @retval SD Card error state
1975   */
1976 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
1977 {
1978   SDIO_CmdInitTypeDef  sdio_cmdinitstructure;
1979   SDIO_DataInitTypeDef sdio_datainitstructure;
1980   HAL_SD_ErrorTypedef errorstate = SD_OK;
1981   uint32_t count = 0;
1982
1983   /* Check SD response */
1984   if ((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1985   {
1986     errorstate = SD_LOCK_UNLOCK_FAILED;
1987
1988     return errorstate;
1989   }
1990
1991   /* Set block size for card if it is not equal to current block size for card */
1992   sdio_cmdinitstructure.Argument         = 64;
1993   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
1994   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1995   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1996   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1997   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1998
1999   /* Check for error conditions */
2000   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
2001
2002   if (errorstate != SD_OK)
2003   {
2004     return errorstate;
2005   }
2006
2007   /* Send CMD55 */
2008   sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
2009   sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
2010   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2011
2012   /* Check for error conditions */
2013   errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2014
2015   if (errorstate != SD_OK)
2016   {
2017     return errorstate;
2018   }
2019
2020   /* Configure the SD DPSM (Data Path State Machine) */
2021   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
2022   sdio_datainitstructure.DataLength    = 64;
2023   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
2024   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
2025   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
2026   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
2027   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
2028
2029   /* Send ACMD13 (SD_APP_STATUS)  with argument as card's RCA */
2030   sdio_cmdinitstructure.Argument         = 0;
2031   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_APP_STATUS;
2032   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2033
2034   /* Check for error conditions */
2035   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STATUS);
2036
2037   if (errorstate != SD_OK)
2038   {
2039     return errorstate;
2040   }
2041
2042   /* Get status data */
2043   while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
2044   {
2045     if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2046     {
2047       for (count = 0; count < 8; count++)
2048       {
2049         *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
2050       }
2051
2052       pSDstatus += 8;
2053     }
2054   }
2055
2056   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
2057   {
2058     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
2059
2060     errorstate = SD_DATA_TIMEOUT;
2061
2062     return errorstate;
2063   }
2064   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2065   {
2066     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
2067
2068     errorstate = SD_DATA_CRC_FAIL;
2069
2070     return errorstate;
2071   }
2072   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2073   {
2074     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
2075
2076     errorstate = SD_RX_OVERRUN;
2077
2078     return errorstate;
2079   }
2080   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
2081   {
2082     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
2083
2084     errorstate = SD_START_BIT_ERR;
2085
2086     return errorstate;
2087   }
2088   else
2089   {
2090     /* No error flag set */
2091   }
2092
2093   count = SD_DATATIMEOUT;
2094   while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
2095   {
2096     *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
2097     pSDstatus++;
2098     count--;
2099   }
2100
2101   /* Clear all the static status flags*/
2102   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2103
2104   return errorstate;
2105 }
2106
2107 /**
2108   * @brief  Gets the current sd card data status.
2109   * @param  hsd: SD handle
2110   * @retval Data Transfer state
2111   */
2112 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
2113 {
2114   HAL_SD_CardStateTypedef cardstate =  SD_CARD_TRANSFER;
2115
2116   /* Get SD card state */
2117   cardstate = SD_GetState(hsd);
2118
2119   /* Find SD status according to card state*/
2120   if (cardstate == SD_CARD_TRANSFER)
2121   {
2122     return SD_TRANSFER_OK;
2123   }
2124   else if(cardstate == SD_CARD_ERROR)
2125   {
2126     return SD_TRANSFER_ERROR;
2127   }
2128   else
2129   {
2130     return SD_TRANSFER_BUSY;
2131   }
2132 }
2133
2134 /**
2135   * @brief  Gets the SD card status.
2136   * @param  hsd: SD handle
2137   * @param  pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
2138   *         will contain the SD card status information
2139   * @retval SD Card error state
2140   */
2141 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
2142 {
2143   HAL_SD_ErrorTypedef errorstate = SD_OK;
2144   uint32_t tmp = 0;
2145   uint32_t sd_status[16];
2146
2147   errorstate = HAL_SD_SendSDStatus(hsd, sd_status);
2148
2149   if (errorstate  != SD_OK)
2150   {
2151     return errorstate;
2152   }
2153
2154   /* Byte 0 */
2155   tmp = (sd_status[0] & 0xC0) >> 6;
2156   pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
2157
2158   /* Byte 0 */
2159   tmp = (sd_status[0] & 0x20) >> 5;
2160   pCardStatus->SECURED_MODE = (uint8_t)tmp;
2161
2162   /* Byte 2 */
2163   tmp = (sd_status[2] & 0xFF);
2164   pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
2165
2166   /* Byte 3 */
2167   tmp = (sd_status[3] & 0xFF);
2168   pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
2169
2170   /* Byte 4 */
2171   tmp = (sd_status[4] & 0xFF);
2172   pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
2173
2174   /* Byte 5 */
2175   tmp = (sd_status[5] & 0xFF);
2176   pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
2177
2178   /* Byte 6 */
2179   tmp = (sd_status[6] & 0xFF);
2180   pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
2181
2182   /* Byte 7 */
2183   tmp = (sd_status[7] & 0xFF);
2184   pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
2185
2186   /* Byte 8 */
2187   tmp = (sd_status[8] & 0xFF);
2188   pCardStatus->SPEED_CLASS = (uint8_t)tmp;
2189
2190   /* Byte 9 */
2191   tmp = (sd_status[9] & 0xFF);
2192   pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
2193
2194   /* Byte 10 */
2195   tmp = (sd_status[10] & 0xF0) >> 4;
2196   pCardStatus->AU_SIZE = (uint8_t)tmp;
2197
2198   /* Byte 11 */
2199   tmp = (sd_status[11] & 0xFF);
2200   pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
2201
2202   /* Byte 12 */
2203   tmp = (sd_status[12] & 0xFF);
2204   pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
2205
2206   /* Byte 13 */
2207   tmp = (sd_status[13] & 0xFC) >> 2;
2208   pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
2209
2210   /* Byte 13 */
2211   tmp = (sd_status[13] & 0x3);
2212   pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
2213
2214   return errorstate;
2215 }
2216
2217 /**
2218   * @}
2219   */
2220
2221 /**
2222   * @}
2223   */
2224
2225 /* Private function ----------------------------------------------------------*/
2226 /** @addtogroup SD_Private_Functions
2227   * @{
2228   */
2229
2230 /**
2231   * @brief  SD DMA transfer complete Rx callback.
2232   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2233   *                the configuration information for the specified DMA module.
2234   * @retval None
2235   */
2236 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
2237 {
2238   SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2239
2240   /* DMA transfer is complete */
2241   hsd->DmaTransferCplt = 1;
2242
2243   /* Wait until SD transfer is complete */
2244   while(hsd->SdTransferCplt == 0)
2245   {
2246   }
2247
2248   /* Disable the DMA channel */
2249   HAL_DMA_Abort(hdma);
2250
2251   /* Transfer complete user callback */
2252   HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
2253 }
2254
2255 /**
2256   * @brief  SD DMA transfer Error Rx callback.
2257   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2258   *                the configuration information for the specified DMA module.
2259   * @retval None
2260   */
2261 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
2262 {
2263   SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2264
2265   /* Transfer complete user callback */
2266   HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
2267 }
2268
2269 /**
2270   * @brief  SD DMA transfer complete Tx callback.
2271   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2272   *                the configuration information for the specified DMA module.
2273   * @retval None
2274   */
2275 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
2276 {
2277   SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2278
2279   /* DMA transfer is complete */
2280   hsd->DmaTransferCplt = 1;
2281
2282   /* Wait until SD transfer is complete */
2283   while(hsd->SdTransferCplt == 0)
2284   {
2285   }
2286
2287   /* Disable the DMA channel */
2288   HAL_DMA_Abort(hdma);
2289
2290   /* Transfer complete user callback */
2291   HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
2292 }
2293
2294 /**
2295   * @brief  SD DMA transfer Error Tx callback.
2296   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2297   *                the configuration information for the specified DMA module.
2298   * @retval None
2299   */
2300 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
2301 {
2302   SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
2303
2304   /* Transfer complete user callback */
2305   HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
2306 }
2307
2308 /**
2309   * @brief  Returns the SD current state.
2310   * @param  hsd: SD handle
2311   * @retval SD card current state
2312   */
2313 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
2314 {
2315   uint32_t resp1 = 0;
2316
2317   if (SD_SendStatus(hsd, &resp1) != SD_OK)
2318   {
2319     return SD_CARD_ERROR;
2320   }
2321   else
2322   {
2323     return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
2324   }
2325 }
2326
2327 /**
2328   * @brief  Initializes all cards or single card as the case may be Card(s) come
2329   *         into standby state.
2330   * @param  hsd: SD handle
2331   * @retval SD Card error state
2332   */
2333 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
2334 {
2335   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2336   HAL_SD_ErrorTypedef errorstate = SD_OK;
2337   uint16_t sd_rca = 1;
2338
2339   if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
2340   {
2341     errorstate = SD_REQUEST_NOT_APPLICABLE;
2342
2343     return errorstate;
2344   }
2345
2346   if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
2347   {
2348     /* Send CMD2 ALL_SEND_CID */
2349     sdio_cmdinitstructure.Argument         = 0;
2350     sdio_cmdinitstructure.CmdIndex         = SD_CMD_ALL_SEND_CID;
2351     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_LONG;
2352     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2353     sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2354     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2355
2356     /* Check for error conditions */
2357     errorstate = SD_CmdResp2Error(hsd);
2358
2359     if(errorstate != SD_OK)
2360     {
2361       return errorstate;
2362     }
2363
2364     /* Get Card identification number data */
2365     hsd->CID[0] = SDIO_GetResponse(SDIO_RESP1);
2366     hsd->CID[1] = SDIO_GetResponse(SDIO_RESP2);
2367     hsd->CID[2] = SDIO_GetResponse(SDIO_RESP3);
2368     hsd->CID[3] = SDIO_GetResponse(SDIO_RESP4);
2369   }
2370
2371   if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1)    || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
2372      (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
2373   {
2374     /* Send CMD3 SET_REL_ADDR with argument 0 */
2375     /* SD Card publishes its RCA. */
2376     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_REL_ADDR;
2377     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2378     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2379
2380     /* Check for error conditions */
2381     errorstate = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
2382
2383     if(errorstate != SD_OK)
2384     {
2385       return errorstate;
2386     }
2387   }
2388
2389   if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
2390   {
2391     /* Get the SD card RCA */
2392     hsd->RCA = sd_rca;
2393
2394     /* Send CMD9 SEND_CSD with argument as card's RCA */
2395     sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
2396     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SEND_CSD;
2397     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_LONG;
2398     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2399
2400     /* Check for error conditions */
2401     errorstate = SD_CmdResp2Error(hsd);
2402
2403     if(errorstate != SD_OK)
2404     {
2405       return errorstate;
2406     }
2407
2408     /* Get Card Specific Data */
2409     hsd->CSD[0] = SDIO_GetResponse(SDIO_RESP1);
2410     hsd->CSD[1] = SDIO_GetResponse(SDIO_RESP2);
2411     hsd->CSD[2] = SDIO_GetResponse(SDIO_RESP3);
2412     hsd->CSD[3] = SDIO_GetResponse(SDIO_RESP4);
2413   }
2414
2415   /* All cards are initialized */
2416   return errorstate;
2417 }
2418
2419 /**
2420   * @brief  Selects of Deselects the corresponding card.
2421   * @param  hsd: SD handle
2422   * @param  addr: Address of the card to be selected
2423   * @retval SD Card error state
2424   */
2425 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
2426 {
2427   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2428   HAL_SD_ErrorTypedef errorstate = SD_OK;
2429
2430   /* Send CMD7 SDIO_SEL_DESEL_CARD */
2431   sdio_cmdinitstructure.Argument         = (uint32_t)addr;
2432   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SEL_DESEL_CARD;
2433   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2434   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2435   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2436   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2437
2438   /* Check for error conditions */
2439   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
2440
2441   return errorstate;
2442 }
2443
2444 /**
2445   * @brief  Enquires cards about their operating voltage and configures clock
2446   *         controls and stores SD information that will be needed in future
2447   *         in the SD handle.
2448   * @param  hsd: SD handle
2449   * @retval SD Card error state
2450   */
2451 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
2452 {
2453   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2454   __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
2455   uint32_t response = 0, count = 0, validvoltage = 0;
2456   uint32_t sdtype = SD_STD_CAPACITY;
2457
2458   /* Power ON Sequence -------------------------------------------------------*/
2459   /* Disable SDIO Clock */
2460   __HAL_SD_SDIO_DISABLE();
2461
2462   /* Set Power State to ON */
2463   SDIO_PowerState_ON(hsd->Instance);
2464
2465   /* 1ms: required power up waiting time before starting the SD initialization
2466      sequence */
2467   HAL_Delay(1);
2468
2469   /* Enable SDIO Clock */
2470   __HAL_SD_SDIO_ENABLE();
2471
2472   /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
2473   /* No CMD response required */
2474   sdio_cmdinitstructure.Argument         = 0;
2475   sdio_cmdinitstructure.CmdIndex         = SD_CMD_GO_IDLE_STATE;
2476   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_NO;
2477   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2478   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2479   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2480
2481   /* Check for error conditions */
2482   errorstate = SD_CmdError(hsd);
2483
2484   if(errorstate != SD_OK)
2485   {
2486     /* CMD Response Timeout (wait for CMDSENT flag) */
2487     return errorstate;
2488   }
2489
2490   /* CMD8: SEND_IF_COND ------------------------------------------------------*/
2491   /* Send CMD8 to verify SD card interface operating condition */
2492   /* Argument: - [31:12]: Reserved (shall be set to '0')
2493   - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
2494   - [7:0]: Check Pattern (recommended 0xAA) */
2495   /* CMD Response: R7 */
2496   sdio_cmdinitstructure.Argument         = SD_CHECK_PATTERN;
2497   sdio_cmdinitstructure.CmdIndex         = SD_SDIO_SEND_IF_COND;
2498   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2499   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2500
2501   /* Check for error conditions */
2502   errorstate = SD_CmdResp7Error(hsd);
2503
2504   if (errorstate == SD_OK)
2505   {
2506     /* SD Card 2.0 */
2507     hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
2508     sdtype        = SD_HIGH_CAPACITY;
2509   }
2510
2511   /* Send CMD55 */
2512   sdio_cmdinitstructure.Argument         = 0;
2513   sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
2514   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2515
2516   /* Check for error conditions */
2517   errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2518
2519   /* If errorstate is Command Timeout, it is a MMC card */
2520   /* If errorstate is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
2521      or SD card 1.x */
2522   if(errorstate == SD_OK)
2523   {
2524     /* SD CARD */
2525     /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2526     while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
2527     {
2528
2529       /* SEND CMD55 APP_CMD with RCA as 0 */
2530       sdio_cmdinitstructure.Argument         = 0;
2531       sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
2532       sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2533       sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2534       sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2535       SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2536
2537       /* Check for error conditions */
2538       errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2539
2540       if(errorstate != SD_OK)
2541       {
2542         return errorstate;
2543       }
2544
2545       /* Send CMD41 */
2546       sdio_cmdinitstructure.Argument         = SD_VOLTAGE_WINDOW_SD | sdtype;
2547       sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_APP_OP_COND;
2548       sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2549       sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2550       sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2551       SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2552
2553       /* Check for error conditions */
2554       errorstate = SD_CmdResp3Error(hsd);
2555
2556       if(errorstate != SD_OK)
2557       {
2558         return errorstate;
2559       }
2560
2561       /* Get command response */
2562       response = SDIO_GetResponse(SDIO_RESP1);
2563
2564       /* Get operating voltage*/
2565       validvoltage = (((response >> 31) == 1) ? 1 : 0);
2566
2567       count++;
2568     }
2569
2570     if(count >= SD_MAX_VOLT_TRIAL)
2571     {
2572       errorstate = SD_INVALID_VOLTRANGE;
2573
2574       return errorstate;
2575     }
2576
2577     if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2578     {
2579       hsd->CardType = HIGH_CAPACITY_SD_CARD;
2580     }
2581
2582   } /* else MMC Card */
2583
2584   return errorstate;
2585 }
2586
2587 /**
2588   * @brief  Turns the SDIO output signals off.
2589   * @param  hsd: SD handle
2590   * @retval SD Card error state
2591   */
2592 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
2593 {
2594   HAL_SD_ErrorTypedef errorstate = SD_OK;
2595
2596   /* Set Power State to OFF */
2597   SDIO_PowerState_OFF(hsd->Instance);
2598
2599   return errorstate;
2600 }
2601
2602 /**
2603   * @brief  Returns the current card's status.
2604   * @param  hsd: SD handle
2605   * @param  pCardStatus: pointer to the buffer that will contain the SD card
2606   *         status (Card Status register)
2607   * @retval SD Card error state
2608   */
2609 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
2610 {
2611   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2612   HAL_SD_ErrorTypedef errorstate = SD_OK;
2613
2614   if(pCardStatus == NULL)
2615   {
2616     errorstate = SD_INVALID_PARAMETER;
2617
2618     return errorstate;
2619   }
2620
2621   /* Send Status command */
2622   sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
2623   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SEND_STATUS;
2624   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2625   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2626   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2627   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2628
2629   /* Check for error conditions */
2630   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
2631
2632   if(errorstate != SD_OK)
2633   {
2634     return errorstate;
2635   }
2636
2637   /* Get SD card status */
2638   *pCardStatus = SDIO_GetResponse(SDIO_RESP1);
2639
2640   return errorstate;
2641 }
2642
2643 /**
2644   * @brief  Checks for error conditions for CMD0.
2645   * @param  hsd: SD handle
2646   * @retval SD Card error state
2647   */
2648 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
2649 {
2650   HAL_SD_ErrorTypedef errorstate = SD_OK;
2651   uint32_t timeout, tmp;
2652
2653   timeout = SDIO_CMD0TIMEOUT;
2654
2655   tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2656
2657   while((timeout > 0) && (!tmp))
2658   {
2659     tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2660     timeout--;
2661   }
2662
2663   if(timeout == 0)
2664   {
2665     errorstate = SD_CMD_RSP_TIMEOUT;
2666     return errorstate;
2667   }
2668
2669   /* Clear all the static flags */
2670   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2671
2672   return errorstate;
2673 }
2674
2675 /**
2676   * @brief  Checks for error conditions for R7 response.
2677   * @param  hsd: SD handle
2678   * @retval SD Card error state
2679   */
2680 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
2681 {
2682   HAL_SD_ErrorTypedef errorstate = SD_ERROR;
2683   uint32_t timeout = SDIO_CMD0TIMEOUT, tmp;
2684
2685   tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2686
2687   while((!tmp) && (timeout > 0))
2688   {
2689     tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2690     timeout--;
2691   }
2692
2693   tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2694
2695   if((timeout == 0) || tmp)
2696   {
2697     /* Card is not V2.0 compliant or card does not support the set voltage range */
2698     errorstate = SD_CMD_RSP_TIMEOUT;
2699
2700     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2701
2702     return errorstate;
2703   }
2704
2705   if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
2706   {
2707     /* Card is SD V2.0 compliant */
2708     errorstate = SD_OK;
2709
2710     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
2711
2712     return errorstate;
2713   }
2714
2715   return errorstate;
2716 }
2717
2718 /**
2719   * @brief  Checks for error conditions for R1 response.
2720   * @param  hsd: SD handle
2721   * @param  SD_CMD: The sent command index
2722   * @retval SD Card error state
2723   */
2724 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
2725 {
2726   HAL_SD_ErrorTypedef errorstate = SD_OK;
2727   uint32_t response_r1;
2728
2729   while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2730   {
2731   }
2732
2733   if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2734   {
2735     errorstate = SD_CMD_RSP_TIMEOUT;
2736
2737     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2738
2739     return errorstate;
2740   }
2741   else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2742   {
2743     errorstate = SD_CMD_CRC_FAIL;
2744
2745     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2746
2747     return errorstate;
2748   }
2749
2750   /* Check response received is of desired command */
2751   if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2752   {
2753     errorstate = SD_ILLEGAL_CMD;
2754
2755     return errorstate;
2756   }
2757
2758   /* Clear all the static flags */
2759   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2760
2761   /* We have received response, retrieve it for analysis  */
2762   response_r1 = SDIO_GetResponse(SDIO_RESP1);
2763
2764   if((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
2765   {
2766     return errorstate;
2767   }
2768
2769   if((response_r1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
2770   {
2771     return(SD_ADDR_OUT_OF_RANGE);
2772   }
2773
2774   if((response_r1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
2775   {
2776     return(SD_ADDR_MISALIGNED);
2777   }
2778
2779   if((response_r1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
2780   {
2781     return(SD_BLOCK_LEN_ERR);
2782   }
2783
2784   if((response_r1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
2785   {
2786     return(SD_ERASE_SEQ_ERR);
2787   }
2788
2789   if((response_r1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
2790   {
2791     return(SD_BAD_ERASE_PARAM);
2792   }
2793
2794   if((response_r1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
2795   {
2796     return(SD_WRITE_PROT_VIOLATION);
2797   }
2798
2799   if((response_r1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
2800   {
2801     return(SD_LOCK_UNLOCK_FAILED);
2802   }
2803
2804   if((response_r1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
2805   {
2806     return(SD_COM_CRC_FAILED);
2807   }
2808
2809   if((response_r1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
2810   {
2811     return(SD_ILLEGAL_CMD);
2812   }
2813
2814   if((response_r1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
2815   {
2816     return(SD_CARD_ECC_FAILED);
2817   }
2818
2819   if((response_r1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
2820   {
2821     return(SD_CC_ERROR);
2822   }
2823
2824   if((response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
2825   {
2826     return(SD_GENERAL_UNKNOWN_ERROR);
2827   }
2828
2829   if((response_r1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
2830   {
2831     return(SD_STREAM_READ_UNDERRUN);
2832   }
2833
2834   if((response_r1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
2835   {
2836     return(SD_STREAM_WRITE_OVERRUN);
2837   }
2838
2839   if((response_r1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
2840   {
2841     return(SD_CID_CSD_OVERWRITE);
2842   }
2843
2844   if((response_r1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
2845   {
2846     return(SD_WP_ERASE_SKIP);
2847   }
2848
2849   if((response_r1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
2850   {
2851     return(SD_CARD_ECC_DISABLED);
2852   }
2853
2854   if((response_r1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
2855   {
2856     return(SD_ERASE_RESET);
2857   }
2858
2859   if((response_r1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
2860   {
2861     return(SD_AKE_SEQ_ERROR);
2862   }
2863
2864   return errorstate;
2865 }
2866
2867 /**
2868   * @brief  Checks for error conditions for R3 (OCR) response.
2869   * @param  hsd: SD handle
2870   * @retval SD Card error state
2871   */
2872 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
2873 {
2874   HAL_SD_ErrorTypedef errorstate = SD_OK;
2875
2876   while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2877   {
2878   }
2879
2880   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2881   {
2882     errorstate = SD_CMD_RSP_TIMEOUT;
2883
2884     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2885
2886     return errorstate;
2887   }
2888
2889   /* Clear all the static flags */
2890   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2891
2892   return errorstate;
2893 }
2894
2895 /**
2896   * @brief  Checks for error conditions for R2 (CID or CSD) response.
2897   * @param  hsd: SD handle
2898   * @retval SD Card error state
2899   */
2900 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
2901 {
2902   HAL_SD_ErrorTypedef errorstate = SD_OK;
2903
2904   while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2905   {
2906   }
2907
2908   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2909   {
2910     errorstate = SD_CMD_RSP_TIMEOUT;
2911
2912     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2913
2914     return errorstate;
2915   }
2916   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2917   {
2918     errorstate = SD_CMD_CRC_FAIL;
2919
2920     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2921
2922     return errorstate;
2923   }
2924   else
2925   {
2926     /* No error flag set */
2927   }
2928
2929   /* Clear all the static flags */
2930   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2931
2932   return errorstate;
2933 }
2934
2935 /**
2936   * @brief  Checks for error conditions for R6 (RCA) response.
2937   * @param  hsd: SD handle
2938   * @param  SD_CMD: The sent command index
2939   * @param  pRCA: Pointer to the variable that will contain the SD card relative
2940   *         address RCA
2941   * @retval SD Card error state
2942   */
2943 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
2944 {
2945   HAL_SD_ErrorTypedef errorstate = SD_OK;
2946   uint32_t response_r1;
2947
2948   while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2949   {
2950   }
2951
2952   if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2953   {
2954     errorstate = SD_CMD_RSP_TIMEOUT;
2955
2956     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2957
2958     return errorstate;
2959   }
2960   else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2961   {
2962     errorstate = SD_CMD_CRC_FAIL;
2963
2964     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2965
2966     return errorstate;
2967   }
2968   else
2969   {
2970     /* No error flag set */
2971   }
2972
2973   /* Check response received is of desired command */
2974   if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2975   {
2976     errorstate = SD_ILLEGAL_CMD;
2977
2978     return errorstate;
2979   }
2980
2981   /* Clear all the static flags */
2982   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2983
2984   /* We have received response, retrieve it.  */
2985   response_r1 = SDIO_GetResponse(SDIO_RESP1);
2986
2987   if((response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
2988   {
2989     *pRCA = (uint16_t) (response_r1 >> 16);
2990
2991     return errorstate;
2992   }
2993
2994   if((response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
2995   {
2996     return(SD_GENERAL_UNKNOWN_ERROR);
2997   }
2998
2999   if((response_r1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
3000   {
3001     return(SD_ILLEGAL_CMD);
3002   }
3003
3004   if((response_r1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
3005   {
3006     return(SD_COM_CRC_FAILED);
3007   }
3008
3009   return errorstate;
3010 }
3011
3012 /**
3013   * @brief  Enables the SDIO wide bus mode.
3014   * @param  hsd: SD handle
3015   * @retval SD Card error state
3016   */
3017 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
3018 {
3019   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3020   HAL_SD_ErrorTypedef errorstate = SD_OK;
3021
3022   uint32_t scr[2] = {0, 0};
3023
3024   if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
3025   {
3026     errorstate = SD_LOCK_UNLOCK_FAILED;
3027
3028     return errorstate;
3029   }
3030
3031   /* Get SCR Register */
3032   errorstate = SD_FindSCR(hsd, scr);
3033
3034   if(errorstate != SD_OK)
3035   {
3036     return errorstate;
3037   }
3038
3039   /* If requested card supports wide bus operation */
3040   if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
3041   {
3042     /* Send CMD55 APP_CMD with argument as card's RCA.*/
3043     sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
3044     sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
3045     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
3046     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3047     sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
3048     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3049
3050     /* Check for error conditions */