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