git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/portable/STM32F4xx/stm32f4xx_hal_sd.c

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