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

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