2 ******************************************************************************
3 * @file stm32f2xx_hal_sd.c
4 * @author MCD Application Team
6 * @date 09-October-2015
7 * @brief SD card HAL module driver.
8 * This file provides firmware functions to manage the following
9 * functionalities of the Secure Digital (SD) peripheral:
10 * + Initialization and de-initialization functions
11 * + IO operation functions
12 * + Peripheral Control functions
13 * + Peripheral State functions
16 ==============================================================================
17 ##### How to use this driver #####
18 ==============================================================================
20 This driver implements a high level communication layer for read and write from/to
21 this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by
22 the user in HAL_SD_MspInit() function (MSP layer).
23 Basically, the MSP layer configuration should be the same as we provide in the
25 You can easily tailor this configuration according to hardware resources.
28 This driver is a generic layered driver for SDIO memories which uses the HAL
29 SDIO driver functions to interface with SD and uSD cards devices.
30 It is used as follows:
32 (#)Initialize the SDIO low level resources by implement the HAL_SD_MspInit() API:
33 (##) Enable the SDIO interface clock using __HAL_RCC_SDIO_CLK_ENABLE();
34 (##) SDIO pins configuration for SD card
35 (+++) Enable the clock for the SDIO GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
36 (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()
37 and according to your pin assignment;
38 (##) DMA Configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
39 and HAL_SD_WriteBlocks_DMA() APIs).
40 (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();
41 (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.
42 (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
43 (+++) Configure the SDIO and DMA interrupt priorities using functions
44 HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority
45 (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()
46 (+++) SDIO interrupts are managed using the macros __HAL_SD_SDIO_ENABLE_IT()
47 and __HAL_SD_SDIO_DISABLE_IT() inside the communication process.
48 (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_SDIO_GET_IT()
49 and __HAL_SD_SDIO_CLEAR_IT()
50 (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
53 *** SD Card Initialization and configuration ***
54 ================================================
56 To initialize the SD Card, use the HAL_SD_Init() function. It Initializes
57 the SD Card and put it into Standby State (Ready for data transfer).
58 This function provide the following operations:
60 (#) Apply the SD Card initialization process at 400KHz and check the SD Card
61 type (Standard Capacity or High Capacity). You can change or adapt this
62 frequency by adjusting the "ClockDiv" field.
63 The SD Card frequency (SDIO_CK) is computed as follows:
65 SDIO_CK = SDIOCLK / (ClockDiv + 2)
67 In initialization mode and according to the SD Card standard,
68 make sure that the SDIO_CK frequency doesn't exceed 400KHz.
70 (#) Get the SD CID and CSD data. All these information are managed by the SDCardInfo
71 structure. This structure provide also ready computed SD Card capacity
74 -@- These information are stored in SD handle structure in case of future use.
76 (#) Configure the SD Card Data transfer frequency. By Default, the card transfer
77 frequency is set to 24MHz. You can change or adapt this frequency by adjusting
79 In transfer mode and according to the SD Card standard, make sure that the
80 SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
81 To be able to use a frequency higher than 24MHz, you should use the SDIO
82 peripheral in bypass mode. Refer to the corresponding reference manual
85 (#) Select the corresponding SD Card according to the address read with the step 2.
87 (#) Configure the SD Card in wide bus mode: 4-bits data.
89 *** SD Card Read operation ***
90 ==============================
92 (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
93 This function support only 512-bytes block length (the block size should be
95 You can choose either one block read operation or multiple block read operation
96 by adjusting the "NumberOfBlocks" parameter.
98 (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
99 This function support only 512-bytes block length (the block size should be
100 chosen as 512 bytes).
101 You can choose either one block read operation or multiple block read operation
102 by adjusting the "NumberOfBlocks" parameter.
103 After this, you have to call the function HAL_SD_CheckReadOperation(), to insure
104 that the read transfer is done correctly in both DMA and SD sides.
106 *** SD Card Write operation ***
107 ===============================
109 (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
110 This function support only 512-bytes block length (the block size should be
111 chosen as 512 bytes).
112 You can choose either one block read operation or multiple block read operation
113 by adjusting the "NumberOfBlocks" parameter.
115 (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
116 This function support only 512-bytes block length (the block size should be
118 You can choose either one block read operation or multiple block read operation
119 by adjusting the "NumberOfBlocks" parameter.
120 After this, you have to call the function HAL_SD_CheckWriteOperation(), to insure
121 that the write transfer is done correctly in both DMA and SD sides.
123 *** SD card status ***
124 ======================
126 (+) At any time, you can check the SD Card status and get the SD card state
127 by using the HAL_SD_GetStatus() function. This function checks first if the
128 SD card is still connected and then get the internal SD Card transfer state.
129 (+) You can also get the SD card SD Status register by using the HAL_SD_SendSDStatus()
132 *** SD HAL driver macros list ***
133 ==================================
135 Below the list of most used macros in SD HAL driver.
137 (+) __HAL_SD_SDIO_ENABLE : Enable the SD device
138 (+) __HAL_SD_SDIO_DISABLE : Disable the SD device
139 (+) __HAL_SD_SDIO_DMA_ENABLE: Enable the SDIO DMA transfer
140 (+) __HAL_SD_SDIO_DMA_DISABLE: Disable the SDIO DMA transfer
141 (+) __HAL_SD_SDIO_ENABLE_IT: Enable the SD device interrupt
142 (+) __HAL_SD_SDIO_DISABLE_IT: Disable the SD device interrupt
143 (+) __HAL_SD_SDIO_GET_FLAG:Check whether the specified SD flag is set or not
144 (+) __HAL_SD_SDIO_CLEAR_FLAG: Clear the SD's pending flags
146 (@) You can refer to the SD HAL driver header file for more useful macros
149 ******************************************************************************
152 * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
154 * Redistribution and use in source and binary forms, with or without modification,
155 * are permitted provided that the following conditions are met:
156 * 1. Redistributions of source code must retain the above copyright notice,
157 * this list of conditions and the following disclaimer.
158 * 2. Redistributions in binary form must reproduce the above copyright notice,
159 * this list of conditions and the following disclaimer in the documentation
160 * and/or other materials provided with the distribution.
161 * 3. Neither the name of STMicroelectronics nor the names of its contributors
162 * may be used to endorse or promote products derived from this software
163 * without specific prior written permission.
165 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
166 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
167 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
168 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
169 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
170 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
171 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
172 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
173 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
174 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
176 ******************************************************************************
179 /* Includes ------------------------------------------------------------------*/
180 #include "stm32f2xx_hal.h"
181 #ifdef HAL_SD_MODULE_ENABLED
183 /** @addtogroup STM32F2xx_HAL_Driver
191 /* Private typedef -----------------------------------------------------------*/
192 /* Private define ------------------------------------------------------------*/
193 /** @addtogroup SD_Private_Defines
197 * @brief SDIO Data block size
199 #define DATA_BLOCK_SIZE ((uint32_t)(9 << 4))
201 * @brief SDIO Static flags, Timeout, FIFO Address
203 #define SDIO_STATIC_FLAGS ((uint32_t)(SDIO_FLAG_CCRCFAIL | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_CTIMEOUT |\
204 SDIO_FLAG_DTIMEOUT | SDIO_FLAG_TXUNDERR | SDIO_FLAG_RXOVERR |\
205 SDIO_FLAG_CMDREND | SDIO_FLAG_CMDSENT | SDIO_FLAG_DATAEND |\
208 #define SDIO_CMD0TIMEOUT ((uint32_t)0x00010000)
211 * @brief Mask for errors Card Status R1 (OCR Register)
213 #define SD_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000)
214 #define SD_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000)
215 #define SD_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000)
216 #define SD_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000)
217 #define SD_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000)
218 #define SD_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000)
219 #define SD_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000)
220 #define SD_OCR_COM_CRC_FAILED ((uint32_t)0x00800000)
221 #define SD_OCR_ILLEGAL_CMD ((uint32_t)0x00400000)
222 #define SD_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000)
223 #define SD_OCR_CC_ERROR ((uint32_t)0x00100000)
224 #define SD_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000)
225 #define SD_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000)
226 #define SD_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000)
227 #define SD_OCR_CID_CSD_OVERWRITE ((uint32_t)0x00010000)
228 #define SD_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000)
229 #define SD_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000)
230 #define SD_OCR_ERASE_RESET ((uint32_t)0x00002000)
231 #define SD_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008)
232 #define SD_OCR_ERRORBITS ((uint32_t)0xFDFFE008)
235 * @brief Masks for R6 Response
237 #define SD_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000)
238 #define SD_R6_ILLEGAL_CMD ((uint32_t)0x00004000)
239 #define SD_R6_COM_CRC_FAILED ((uint32_t)0x00008000)
241 #define SD_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000)
242 #define SD_HIGH_CAPACITY ((uint32_t)0x40000000)
243 #define SD_STD_CAPACITY ((uint32_t)0x00000000)
244 #define SD_CHECK_PATTERN ((uint32_t)0x000001AA)
246 #define SD_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFF)
247 #define SD_ALLZERO ((uint32_t)0x00000000)
249 #define SD_WIDE_BUS_SUPPORT ((uint32_t)0x00040000)
250 #define SD_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000)
251 #define SD_CARD_LOCKED ((uint32_t)0x02000000)
253 #define SD_DATATIMEOUT ((uint32_t)0xFFFFFFFF)
254 #define SD_0TO7BITS ((uint32_t)0x000000FF)
255 #define SD_8TO15BITS ((uint32_t)0x0000FF00)
256 #define SD_16TO23BITS ((uint32_t)0x00FF0000)
257 #define SD_24TO31BITS ((uint32_t)0xFF000000)
258 #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFF)
260 #define SD_HALFFIFO ((uint32_t)0x00000008)
261 #define SD_HALFFIFOBYTES ((uint32_t)0x00000020)
264 * @brief Command Class Supported
266 #define SD_CCCC_LOCK_UNLOCK ((uint32_t)0x00000080)
267 #define SD_CCCC_WRITE_PROT ((uint32_t)0x00000040)
268 #define SD_CCCC_ERASE ((uint32_t)0x00000020)
271 * @brief Following commands are SD Card Specific commands.
272 * SDIO_APP_CMD should be sent before sending these commands.
274 #define SD_SDIO_SEND_IF_COND ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
280 /* Private macro -------------------------------------------------------------*/
281 /* Private variables ---------------------------------------------------------*/
282 /* Private function prototypes -----------------------------------------------*/
283 /** @addtogroup SD_Private_Functions_Prototypes
286 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
287 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
288 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd);
289 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
290 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
291 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
292 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
293 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
294 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
295 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
296 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
297 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
298 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
299 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
300 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
301 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
302 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
303 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
304 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
305 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
309 /* Exported functions --------------------------------------------------------*/
310 /** @addtogroup SD_Exported_Functions
314 /** @addtogroup SD_Exported_Functions_Group1
315 * @brief Initialization and de-initialization functions
318 ==============================================================================
319 ##### Initialization and de-initialization functions #####
320 ==============================================================================
322 This section provides functions allowing to initialize/de-initialize the SD
323 card device to be ready for use.
331 * @brief Initializes the SD card according to the specified parameters in the
332 SD_HandleTypeDef and create the associated handle.
333 * @param hsd: SD handle
334 * @param SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information
335 * @retval HAL SD error state
337 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
339 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
340 SD_InitTypeDef tmpinit;
342 /* Allocate lock resource and initialize it */
343 hsd->Lock = HAL_UNLOCKED;
344 /* Initialize the low level hardware (MSP) */
347 /* Default SDIO peripheral configuration for SD card initialization */
348 tmpinit.ClockEdge = SDIO_CLOCK_EDGE_RISING;
349 tmpinit.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
350 tmpinit.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
351 tmpinit.BusWide = SDIO_BUS_WIDE_1B;
352 tmpinit.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
353 tmpinit.ClockDiv = SDIO_INIT_CLK_DIV;
355 /* Initialize SDIO peripheral interface with default configuration */
356 SDIO_Init(hsd->Instance, tmpinit);
358 /* Identify card operating voltage */
359 errorstate = SD_PowerON(hsd);
361 if(errorstate != SD_OK)
366 /* Initialize the present SDIO card(s) and put them in idle state */
367 errorstate = SD_Initialize_Cards(hsd);
369 if (errorstate != SD_OK)
374 /* Read CSD/CID MSD registers */
375 errorstate = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
377 if (errorstate == SD_OK)
379 /* Select the Card */
380 errorstate = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
383 /* Configure SDIO peripheral interface */
384 SDIO_Init(hsd->Instance, hsd->Init);
390 * @brief De-Initializes the SD card.
391 * @param hsd: SD handle
394 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
397 /* Set SD power state to off */
400 /* De-Initialize the MSP layer */
401 HAL_SD_MspDeInit(hsd);
408 * @brief Initializes the SD MSP.
409 * @param hsd: SD handle
412 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
414 /* NOTE : This function Should not be modified, when the callback is needed,
415 the HAL_SD_MspInit could be implemented in the user file
420 * @brief De-Initialize SD MSP.
421 * @param hsd: SD handle
424 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
426 /* NOTE : This function Should not be modified, when the callback is needed,
427 the HAL_SD_MspDeInit could be implemented in the user file
435 /** @addtogroup SD_Exported_Functions_Group2
436 * @brief Data transfer functions
439 ==============================================================================
440 ##### IO operation functions #####
441 ==============================================================================
443 This subsection provides a set of functions allowing to manage the data
444 transfer from/to SD card.
451 * @brief Reads block(s) from a specified address in a card. The Data transfer
452 * is managed by polling mode.
453 * @param hsd: SD handle
454 * @param pReadBuffer: pointer to the buffer that will contain the received data
455 * @param ReadAddr: Address from where data is to be read
456 * @param BlockSize: SD card Data block size
457 * @note BlockSize must be 512 bytes.
458 * @param NumberOfBlocks: Number of SD blocks to read
459 * @retval SD Card error state
461 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
463 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
464 SDIO_DataInitTypeDef sdio_datainitstructure;
465 HAL_SD_ErrorTypedef errorstate = SD_OK;
466 uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
468 /* Initialize data control register */
469 hsd->Instance->DCTRL = 0;
471 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
477 /* Set Block Size for Card */
478 sdio_cmdinitstructure.Argument = (uint32_t) BlockSize;
479 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
480 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
481 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
482 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
483 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
485 /* Check for error conditions */
486 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
488 if (errorstate != SD_OK)
493 /* Configure the SD DPSM (Data Path State Machine) */
494 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
495 sdio_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
496 sdio_datainitstructure.DataBlockSize = DATA_BLOCK_SIZE;
497 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
498 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
499 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
500 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
502 if(NumberOfBlocks > 1)
504 /* Send CMD18 READ_MULT_BLOCK with argument data address */
505 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
509 /* Send CMD17 READ_SINGLE_BLOCK */
510 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
513 sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
514 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
516 /* Read block(s) in polling mode */
517 if(NumberOfBlocks > 1)
519 /* Check for error conditions */
520 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
522 if (errorstate != SD_OK)
527 /* Poll on SDIO flags */
528 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
530 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
532 /* Read data from SDIO Rx FIFO */
533 for (count = 0; count < 8; count++)
535 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
544 /* Check for error conditions */
545 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
547 if (errorstate != SD_OK)
552 /* In case of single block transfer, no need of stop transfer at all */
553 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
555 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
557 /* Read data from SDIO Rx FIFO */
558 for (count = 0; count < 8; count++)
560 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
568 /* Send stop transmission command in case of multiblock read */
569 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
571 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
572 (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
573 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
575 /* Send stop transmission command */
576 errorstate = HAL_SD_StopTransfer(hsd);
580 /* Get error state */
581 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
583 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
585 errorstate = SD_DATA_TIMEOUT;
589 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
591 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
593 errorstate = SD_DATA_CRC_FAIL;
597 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
599 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
601 errorstate = SD_RX_OVERRUN;
605 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
607 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
609 errorstate = SD_START_BIT_ERR;
615 /* No error flag set */
618 count = SD_DATATIMEOUT;
620 /* Empty FIFO if there is still any data */
621 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
623 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
628 /* Clear all the static flags */
629 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
635 * @brief Allows to write block(s) to a specified address in a card. The Data
636 * transfer is managed by polling mode.
637 * @param hsd: SD handle
638 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
639 * @param WriteAddr: Address from where data is to be written
640 * @param BlockSize: SD card Data block size
641 * @note BlockSize must be 512 bytes.
642 * @param NumberOfBlocks: Number of SD blocks to write
643 * @retval SD Card error state
645 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
647 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
648 SDIO_DataInitTypeDef sdio_datainitstructure;
649 HAL_SD_ErrorTypedef errorstate = SD_OK;
650 uint32_t totalnumberofbytes = 0, bytestransferred = 0, count = 0, restwords = 0;
651 uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
652 uint8_t cardstate = 0;
654 /* Initialize data control register */
655 hsd->Instance->DCTRL = 0;
657 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
663 /* Set Block Size for Card */
664 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
665 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
666 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
667 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
668 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
669 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
671 /* Check for error conditions */
672 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
674 if (errorstate != SD_OK)
679 if(NumberOfBlocks > 1)
681 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
682 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
686 /* Send CMD24 WRITE_SINGLE_BLOCK */
687 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
690 sdio_cmdinitstructure.Argument = (uint32_t)WriteAddr;
691 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
693 /* Check for error conditions */
694 if(NumberOfBlocks > 1)
696 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
700 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
703 if (errorstate != SD_OK)
708 /* Set total number of bytes to write */
709 totalnumberofbytes = NumberOfBlocks * BlockSize;
711 /* Configure the SD DPSM (Data Path State Machine) */
712 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
713 sdio_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
714 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
715 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
716 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
717 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
718 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
720 /* Write block(s) in polling mode */
721 if(NumberOfBlocks > 1)
723 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
725 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
727 if ((totalnumberofbytes - bytestransferred) < 32)
729 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
731 /* Write data to SDIO Tx FIFO */
732 for (count = 0; count < restwords; count++)
734 SDIO_WriteFIFO(hsd->Instance, tempbuff);
736 bytestransferred += 4;
741 /* Write data to SDIO Tx FIFO */
742 for (count = 0; count < 8; count++)
744 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
748 bytestransferred += 32;
755 /* In case of single data block transfer no need of stop command at all */
756 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
758 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
760 if ((totalnumberofbytes - bytestransferred) < 32)
762 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
764 /* Write data to SDIO Tx FIFO */
765 for (count = 0; count < restwords; count++)
767 SDIO_WriteFIFO(hsd->Instance, tempbuff);
769 bytestransferred += 4;
774 /* Write data to SDIO Tx FIFO */
775 for (count = 0; count < 8; count++)
777 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
781 bytestransferred += 32;
787 /* Send stop transmission command in case of multiblock write */
788 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
790 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
791 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
793 /* Send stop transmission command */
794 errorstate = HAL_SD_StopTransfer(hsd);
798 /* Get error state */
799 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
801 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
803 errorstate = SD_DATA_TIMEOUT;
807 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
809 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
811 errorstate = SD_DATA_CRC_FAIL;
815 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
817 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
819 errorstate = SD_TX_UNDERRUN;
823 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
825 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
827 errorstate = SD_START_BIT_ERR;
833 /* No error flag set */
836 /* Clear all the static flags */
837 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
839 /* Wait till the card is in programming state */
840 errorstate = SD_IsCardProgramming(hsd, &cardstate);
842 while ((errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
844 errorstate = SD_IsCardProgramming(hsd, &cardstate);
851 * @brief Reads block(s) from a specified address in a card. The Data transfer
852 * is managed by DMA mode.
853 * @note This API should be followed by the function HAL_SD_CheckReadOperation()
854 * to check the completion of the read process
855 * @param hsd: SD handle
856 * @param pReadBuffer: Pointer to the buffer that will contain the received data
857 * @param ReadAddr: Address from where data is to be read
858 * @param BlockSize: SD card Data block size
859 * @note BlockSize must be 512 bytes.
860 * @param NumberOfBlocks: Number of blocks to read.
861 * @retval SD Card error state
863 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
865 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
866 SDIO_DataInitTypeDef sdio_datainitstructure;
867 HAL_SD_ErrorTypedef errorstate = SD_OK;
869 /* Initialize data control register */
870 hsd->Instance->DCTRL = 0;
872 /* Initialize handle flags */
873 hsd->SdTransferCplt = 0;
874 hsd->DmaTransferCplt = 0;
875 hsd->SdTransferErr = SD_OK;
877 /* Initialize SD Read operation */
878 if(NumberOfBlocks > 1)
880 hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
884 hsd->SdOperation = SD_READ_SINGLE_BLOCK;
887 /* Enable transfer interrupts */
888 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
894 /* Enable SDIO DMA transfer */
895 __HAL_SD_SDIO_DMA_ENABLE();
897 /* Configure DMA user callbacks */
898 hsd->hdmarx->XferCpltCallback = SD_DMA_RxCplt;
899 hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
901 /* Enable the DMA Stream */
902 HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks)/4);
904 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
910 /* Set Block Size for Card */
911 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
912 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
913 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
914 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
915 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
916 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
918 /* Check for error conditions */
919 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
921 if (errorstate != SD_OK)
926 /* Configure the SD DPSM (Data Path State Machine) */
927 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
928 sdio_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
929 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
930 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
931 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
932 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
933 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
935 /* Check number of blocks command */
936 if(NumberOfBlocks > 1)
938 /* Send CMD18 READ_MULT_BLOCK with argument data address */
939 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
943 /* Send CMD17 READ_SINGLE_BLOCK */
944 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
947 sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
948 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
950 /* Check for error conditions */
951 if(NumberOfBlocks > 1)
953 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
957 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
960 /* Update the SD transfer error in SD handle */
961 hsd->SdTransferErr = errorstate;
968 * @brief Writes block(s) to a specified address in a card. The Data transfer
969 * is managed by DMA mode.
970 * @note This API should be followed by the function HAL_SD_CheckWriteOperation()
971 * to check the completion of the write process (by SD current status polling).
972 * @param hsd: SD handle
973 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
974 * @param WriteAddr: Address from where data is to be read
975 * @param BlockSize: the SD card Data block size
976 * @note BlockSize must be 512 bytes.
977 * @param NumberOfBlocks: Number of blocks to write
978 * @retval SD Card error state
980 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
982 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
983 SDIO_DataInitTypeDef sdio_datainitstructure;
984 HAL_SD_ErrorTypedef errorstate = SD_OK;
986 /* Initialize data control register */
987 hsd->Instance->DCTRL = 0;
989 /* Initialize handle flags */
990 hsd->SdTransferCplt = 0;
991 hsd->DmaTransferCplt = 0;
992 hsd->SdTransferErr = SD_OK;
994 /* Initialize SD Write operation */
995 if(NumberOfBlocks > 1)
997 hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
1001 hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
1004 /* Enable transfer interrupts */
1005 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
1011 /* Configure DMA user callbacks */
1012 hsd->hdmatx->XferCpltCallback = SD_DMA_TxCplt;
1013 hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
1015 /* Enable the DMA Stream */
1016 HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BlockSize * NumberOfBlocks)/4);
1018 /* Enable SDIO DMA transfer */
1019 __HAL_SD_SDIO_DMA_ENABLE();
1021 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1027 /* Set Block Size for Card */
1028 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
1029 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1030 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1031 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1032 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1033 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1035 /* Check for error conditions */
1036 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1038 if (errorstate != SD_OK)
1043 /* Check number of blocks command */
1044 if(NumberOfBlocks <= 1)
1046 /* Send CMD24 WRITE_SINGLE_BLOCK */
1047 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
1051 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
1052 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
1055 sdio_cmdinitstructure.Argument = (uint32_t)WriteAddr;
1056 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1058 /* Check for error conditions */
1059 if(NumberOfBlocks > 1)
1061 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
1065 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
1068 if (errorstate != SD_OK)
1073 /* Configure the SD DPSM (Data Path State Machine) */
1074 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
1075 sdio_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
1076 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1077 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1078 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1079 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
1080 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1082 hsd->SdTransferErr = errorstate;
1088 * @brief This function waits until the SD DMA data read transfer is finished.
1089 * This API should be called after HAL_SD_ReadBlocks_DMA() function
1090 * to insure that all data sent by the card is already transferred by the
1092 * @param hsd: SD handle
1093 * @param Timeout: Timeout duration
1094 * @retval SD Card error state
1096 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1098 HAL_SD_ErrorTypedef errorstate = SD_OK;
1099 uint32_t timeout = Timeout;
1100 uint32_t tmp1, tmp2;
1101 HAL_SD_ErrorTypedef tmp3;
1103 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1104 tmp1 = hsd->DmaTransferCplt;
1105 tmp2 = hsd->SdTransferCplt;
1106 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1108 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1110 tmp1 = hsd->DmaTransferCplt;
1111 tmp2 = hsd->SdTransferCplt;
1112 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1118 /* Wait until the Rx transfer is no longer active. IE. fifo is empty.
1119 Once FIFO is empty, the DMA will have finished and DmaTransferCplt should
1121 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXACT)) && (timeout > 0))
1126 /* Send stop command in multiblock read */
1127 if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
1129 errorstate = HAL_SD_StopTransfer(hsd);
1132 if ((timeout == 0) && (errorstate == SD_OK))
1134 errorstate = SD_DATA_TIMEOUT;
1137 /* Clear all the static flags */
1138 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1140 /* Return error state */
1141 if (hsd->SdTransferErr != SD_OK)
1143 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1150 * @brief This function waits until the SD DMA data write transfer is finished.
1151 * This API should be called after HAL_SD_WriteBlocks_DMA() function
1152 * to insure that all data sent by the card is already transferred by the
1154 * @param hsd: SD handle
1155 * @param Timeout: Timeout duration
1156 * @retval SD Card error state
1158 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1160 HAL_SD_ErrorTypedef errorstate = SD_OK;
1161 uint32_t timeout = Timeout;
1162 uint32_t tmp1, tmp2;
1163 HAL_SD_ErrorTypedef tmp3;
1165 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1166 tmp1 = hsd->DmaTransferCplt;
1167 tmp2 = hsd->SdTransferCplt;
1168 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1170 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1172 tmp1 = hsd->DmaTransferCplt;
1173 tmp2 = hsd->SdTransferCplt;
1174 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1180 /* Wait until the Tx transfer is no longer active */
1181 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXACT)) && (timeout > 0))
1186 /* Send stop command in multiblock write */
1187 if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
1189 errorstate = HAL_SD_StopTransfer(hsd);
1192 if ((timeout == 0) && (errorstate == SD_OK))
1194 errorstate = SD_DATA_TIMEOUT;
1197 /* Clear all the static flags */
1198 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1200 /* Return error state */
1201 if (hsd->SdTransferErr != SD_OK)
1203 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1206 /* Wait until write is complete */
1207 while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
1215 * @brief Erases the specified memory area of the given SD card.
1216 * @param hsd: SD handle
1217 * @param startaddr: Start byte address
1218 * @param endaddr: End byte address
1219 * @retval SD Card error state
1221 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
1223 HAL_SD_ErrorTypedef errorstate = SD_OK;
1224 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1227 __IO uint32_t maxdelay = 0;
1228 uint8_t cardstate = 0;
1230 /* Check if the card command class supports erase command */
1231 if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
1233 errorstate = SD_REQUEST_NOT_APPLICABLE;
1238 /* Get max delay value */
1239 maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
1241 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1243 errorstate = SD_LOCK_UNLOCK_FAILED;
1248 /* Get start and end block for high capacity cards */
1249 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1255 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1256 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1257 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1259 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
1260 sdio_cmdinitstructure.Argument =(uint32_t)startaddr;
1261 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_START;
1262 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1263 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1264 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1265 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1267 /* Check for error conditions */
1268 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
1270 if (errorstate != SD_OK)
1275 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
1276 sdio_cmdinitstructure.Argument = (uint32_t)endaddr;
1277 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_END;
1278 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1280 /* Check for error conditions */
1281 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
1283 if (errorstate != SD_OK)
1289 /* Send CMD38 ERASE */
1290 sdio_cmdinitstructure.Argument = 0;
1291 sdio_cmdinitstructure.CmdIndex = SD_CMD_ERASE;
1292 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1294 /* Check for error conditions */
1295 errorstate = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
1297 if (errorstate != SD_OK)
1302 for (; delay < maxdelay; delay++)
1306 /* Wait until the card is in programming state */
1307 errorstate = SD_IsCardProgramming(hsd, &cardstate);
1309 delay = SD_DATATIMEOUT;
1311 while ((delay > 0) && (errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
1313 errorstate = SD_IsCardProgramming(hsd, &cardstate);
1321 * @brief This function handles SD card interrupt request.
1322 * @param hsd: SD handle
1325 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1327 /* Check for SDIO interrupt flags */
1328 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DATAEND))
1330 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_IT_DATAEND);
1332 /* SD transfer is complete */
1333 hsd->SdTransferCplt = 1;
1335 /* No transfer error */
1336 hsd->SdTransferErr = SD_OK;
1338 HAL_SD_XferCpltCallback(hsd);
1340 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DCRCFAIL))
1342 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1344 hsd->SdTransferErr = SD_DATA_CRC_FAIL;
1346 HAL_SD_XferErrorCallback(hsd);
1349 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DTIMEOUT))
1351 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1353 hsd->SdTransferErr = SD_DATA_TIMEOUT;
1355 HAL_SD_XferErrorCallback(hsd);
1357 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_RXOVERR))
1359 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1361 hsd->SdTransferErr = SD_RX_OVERRUN;
1363 HAL_SD_XferErrorCallback(hsd);
1365 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_TXUNDERR))
1367 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
1369 hsd->SdTransferErr = SD_TX_UNDERRUN;
1371 HAL_SD_XferErrorCallback(hsd);
1373 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_STBITERR))
1375 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1377 hsd->SdTransferErr = SD_START_BIT_ERR;
1379 HAL_SD_XferErrorCallback(hsd);
1383 /* No error flag set */
1386 /* Disable all SDIO peripheral interrupt sources */
1387 __HAL_SD_SDIO_DISABLE_IT(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |\
1388 SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |\
1389 SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1394 * @brief SD end of transfer callback.
1395 * @param hsd: SD handle
1398 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
1400 /* NOTE : This function Should not be modified, when the callback is needed,
1401 the HAL_SD_XferCpltCallback could be implemented in the user file
1406 * @brief SD Transfer Error callback.
1407 * @param hsd: SD handle
1410 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
1412 /* NOTE : This function Should not be modified, when the callback is needed,
1413 the HAL_SD_XferErrorCallback could be implemented in the user file
1418 * @brief SD Transfer complete Rx callback in non blocking mode.
1419 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1420 * the configuration information for the specified DMA module.
1423 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
1425 /* NOTE : This function Should not be modified, when the callback is needed,
1426 the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
1431 * @brief SD DMA transfer complete Rx error callback.
1432 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1433 * the configuration information for the specified DMA module.
1436 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
1438 /* NOTE : This function Should not be modified, when the callback is needed,
1439 the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
1444 * @brief SD Transfer complete Tx callback in non blocking mode.
1445 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1446 * the configuration information for the specified DMA module.
1449 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
1451 /* NOTE : This function Should not be modified, when the callback is needed,
1452 the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
1457 * @brief SD DMA transfer complete error Tx callback.
1458 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1459 * the configuration information for the specified DMA module.
1462 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
1464 /* NOTE : This function Should not be modified, when the callback is needed,
1465 the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
1473 /** @addtogroup SD_Exported_Functions_Group3
1474 * @brief management functions
1477 ==============================================================================
1478 ##### Peripheral Control functions #####
1479 ==============================================================================
1481 This subsection provides a set of functions allowing to control the SD card
1489 * @brief Returns information about specific card.
1490 * @param hsd: SD handle
1491 * @param pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
1492 * contains all SD cardinformation
1493 * @retval SD Card error state
1495 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
1497 HAL_SD_ErrorTypedef errorstate = SD_OK;
1500 pCardInfo->CardType = (uint8_t)(hsd->CardType);
1501 pCardInfo->RCA = (uint16_t)(hsd->RCA);
1504 tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
1505 pCardInfo->SD_csd.CSDStruct = (uint8_t)((tmp & 0xC0) >> 6);
1506 pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
1507 pCardInfo->SD_csd.Reserved1 = tmp & 0x03;
1510 tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
1511 pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
1514 tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
1515 pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
1518 tmp = hsd->CSD[0] & 0x000000FF;
1519 pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
1522 tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
1523 pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
1526 tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
1527 pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
1528 pCardInfo->SD_csd.RdBlockLen = (uint8_t)(tmp & 0x0F);
1531 tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
1532 pCardInfo->SD_csd.PartBlockRead = (uint8_t)((tmp & 0x80) >> 7);
1533 pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
1534 pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
1535 pCardInfo->SD_csd.DSRImpl = (uint8_t)((tmp & 0x10) >> 4);
1536 pCardInfo->SD_csd.Reserved2 = 0; /*!< Reserved */
1538 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
1540 pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
1543 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1544 pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
1547 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1548 pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
1550 pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
1551 pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
1554 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1555 pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
1556 pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
1557 pCardInfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
1559 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1560 pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
1562 pCardInfo->CardCapacity = (pCardInfo->SD_csd.DeviceSize + 1) ;
1563 pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
1564 pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
1565 pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
1567 else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1570 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1571 pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
1574 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1576 pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
1579 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1581 pCardInfo->SD_csd.DeviceSize |= (tmp);
1584 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1586 pCardInfo->CardCapacity = (uint64_t)((((uint64_t)pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024);
1587 pCardInfo->CardBlockSize = 512;
1591 /* Not supported card type */
1592 errorstate = SD_ERROR;
1595 pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
1596 pCardInfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
1599 tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
1600 pCardInfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
1601 pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
1604 tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
1605 pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
1606 pCardInfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
1607 pCardInfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
1608 pCardInfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
1611 tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
1612 pCardInfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
1613 pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
1614 pCardInfo->SD_csd.Reserved3 = 0;
1615 pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
1618 tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
1619 pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
1620 pCardInfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
1621 pCardInfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
1622 pCardInfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
1623 pCardInfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
1624 pCardInfo->SD_csd.ECC = (tmp & 0x03);
1627 tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
1628 pCardInfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
1629 pCardInfo->SD_csd.Reserved4 = 1;
1632 tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
1633 pCardInfo->SD_cid.ManufacturerID = tmp;
1636 tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
1637 pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
1640 tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
1641 pCardInfo->SD_cid.OEM_AppliID |= tmp;
1644 tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
1645 pCardInfo->SD_cid.ProdName1 = tmp << 24;
1648 tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
1649 pCardInfo->SD_cid.ProdName1 |= tmp << 16;
1652 tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
1653 pCardInfo->SD_cid.ProdName1 |= tmp << 8;
1656 tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
1657 pCardInfo->SD_cid.ProdName1 |= tmp;
1660 tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
1661 pCardInfo->SD_cid.ProdName2 = tmp;
1664 tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
1665 pCardInfo->SD_cid.ProdRev = tmp;
1668 tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
1669 pCardInfo->SD_cid.ProdSN = tmp << 24;
1672 tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
1673 pCardInfo->SD_cid.ProdSN |= tmp << 16;
1676 tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
1677 pCardInfo->SD_cid.ProdSN |= tmp << 8;
1680 tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
1681 pCardInfo->SD_cid.ProdSN |= tmp;
1684 tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
1685 pCardInfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
1686 pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
1689 tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
1690 pCardInfo->SD_cid.ManufactDate |= tmp;
1693 tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
1694 pCardInfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
1695 pCardInfo->SD_cid.Reserved2 = 1;
1701 * @brief Enables wide bus operation for the requested card if supported by
1703 * @param hsd: SD handle
1704 * @param WideMode: Specifies the SD card wide bus mode
1705 * This parameter can be one of the following values:
1706 * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
1707 * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
1708 * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
1709 * @retval SD Card error state
1711 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
1713 HAL_SD_ErrorTypedef errorstate = SD_OK;
1714 SDIO_InitTypeDef tmpinit;
1716 /* MMC Card does not support this feature */
1717 if (hsd->CardType == MULTIMEDIA_CARD)
1719 errorstate = SD_UNSUPPORTED_FEATURE;
1723 else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1724 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1726 if (WideMode == SDIO_BUS_WIDE_8B)
1728 errorstate = SD_UNSUPPORTED_FEATURE;
1730 else if (WideMode == SDIO_BUS_WIDE_4B)
1732 errorstate = SD_WideBus_Enable(hsd);
1734 else if (WideMode == SDIO_BUS_WIDE_1B)
1736 errorstate = SD_WideBus_Disable(hsd);
1740 /* WideMode is not a valid argument*/
1741 errorstate = SD_INVALID_PARAMETER;
1744 if (errorstate == SD_OK)
1746 /* Configure the SDIO peripheral */
1747 tmpinit.ClockEdge = hsd->Init.ClockEdge;
1748 tmpinit.ClockBypass = hsd->Init.ClockBypass;
1749 tmpinit.ClockPowerSave = hsd->Init.ClockPowerSave;
1750 tmpinit.BusWide = WideMode;
1751 tmpinit.HardwareFlowControl = hsd->Init.HardwareFlowControl;
1752 tmpinit.ClockDiv = hsd->Init.ClockDiv;
1753 SDIO_Init(hsd->Instance, tmpinit);
1761 * @brief Aborts an ongoing data transfer.
1762 * @param hsd: SD handle
1763 * @retval SD Card error state
1765 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
1767 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1768 HAL_SD_ErrorTypedef errorstate = SD_OK;
1770 /* Send CMD12 STOP_TRANSMISSION */
1771 sdio_cmdinitstructure.Argument = 0;
1772 sdio_cmdinitstructure.CmdIndex = SD_CMD_STOP_TRANSMISSION;
1773 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1774 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1775 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1776 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1778 /* Check for error conditions */
1779 errorstate = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
1785 * @brief Switches the SD card to High Speed mode.
1786 * This API must be used after "Transfer State"
1787 * @note This operation should be followed by the configuration
1788 * of PLL to have SDIOCK clock between 67 and 75 MHz
1789 * @param hsd: SD handle
1790 * @retval SD Card error state
1792 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
1794 HAL_SD_ErrorTypedef errorstate = SD_OK;
1795 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1796 SDIO_DataInitTypeDef sdio_datainitstructure;
1798 uint8_t SD_hs[64] = {0};
1799 uint32_t SD_scr[2] = {0, 0};
1800 uint32_t SD_SPEC = 0 ;
1801 uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
1803 /* Initialize the Data control register */
1804 hsd->Instance->DCTRL = 0;
1806 /* Get SCR Register */
1807 errorstate = SD_FindSCR(hsd, SD_scr);
1809 if (errorstate != SD_OK)
1814 /* Test the Version supported by the card*/
1815 SD_SPEC = (SD_scr[1] & 0x01000000) | (SD_scr[1] & 0x02000000);
1817 if (SD_SPEC != SD_ALLZERO)
1819 /* Set Block Size for Card */
1820 sdio_cmdinitstructure.Argument = (uint32_t)64;
1821 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1822 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1823 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1824 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1825 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1827 /* Check for error conditions */
1828 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1830 if (errorstate != SD_OK)
1835 /* Configure the SD DPSM (Data Path State Machine) */
1836 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
1837 sdio_datainitstructure.DataLength = 64;
1838 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
1839 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1840 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1841 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
1842 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1844 /* Send CMD6 switch mode */
1845 sdio_cmdinitstructure.Argument = 0x80FFFF01;
1846 sdio_cmdinitstructure.CmdIndex = SD_CMD_HS_SWITCH;
1847 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1849 /* Check for error conditions */
1850 errorstate = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
1852 if (errorstate != SD_OK)
1857 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
1859 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
1861 for (count = 0; count < 8; count++)
1863 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
1870 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
1872 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1874 errorstate = SD_DATA_TIMEOUT;
1878 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
1880 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1882 errorstate = SD_DATA_CRC_FAIL;
1886 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
1888 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1890 errorstate = SD_RX_OVERRUN;
1894 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
1896 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1898 errorstate = SD_START_BIT_ERR;
1904 /* No error flag set */
1907 count = SD_DATATIMEOUT;
1909 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
1911 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
1916 /* Clear all the static flags */
1917 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1919 /* Test if the switch mode HS is ok */
1920 if ((SD_hs[13]& 2) != 2)
1922 errorstate = SD_UNSUPPORTED_FEATURE;
1933 /** @addtogroup SD_Exported_Functions_Group4
1934 * @brief Peripheral State functions
1937 ==============================================================================
1938 ##### Peripheral State functions #####
1939 ==============================================================================
1941 This subsection permits to get in runtime the status of the peripheral
1949 * @brief Returns the current SD card's status.
1950 * @param hsd: SD handle
1951 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
1952 * SD Status register)
1953 * @retval SD Card error state
1955 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
1957 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1958 SDIO_DataInitTypeDef sdio_datainitstructure;
1959 HAL_SD_ErrorTypedef errorstate = SD_OK;
1962 /* Check SD response */
1963 if ((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1965 errorstate = SD_LOCK_UNLOCK_FAILED;
1970 /* Set block size for card if it is not equal to current block size for card */
1971 sdio_cmdinitstructure.Argument = 64;
1972 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1973 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1974 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1975 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1976 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1978 /* Check for error conditions */
1979 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1981 if (errorstate != SD_OK)
1987 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
1988 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
1989 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1991 /* Check for error conditions */
1992 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
1994 if (errorstate != SD_OK)
1999 /* Configure the SD DPSM (Data Path State Machine) */
2000 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
2001 sdio_datainitstructure.DataLength = 64;
2002 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
2003 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
2004 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
2005 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
2006 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
2008 /* Send ACMD13 (SD_APP_STATUS) with argument as card's RCA */
2009 sdio_cmdinitstructure.Argument = 0;
2010 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_STATUS;
2011 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2013 /* Check for error conditions */
2014 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STATUS);
2016 if (errorstate != SD_OK)
2021 /* Get status data */
2022 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
2024 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2026 for (count = 0; count < 8; count++)
2028 *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
2035 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
2037 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
2039 errorstate = SD_DATA_TIMEOUT;
2043 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2045 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
2047 errorstate = SD_DATA_CRC_FAIL;
2051 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2053 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
2055 errorstate = SD_RX_OVERRUN;
2059 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
2061 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
2063 errorstate = SD_START_BIT_ERR;
2069 /* No error flag set */
2072 count = SD_DATATIMEOUT;
2073 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
2075 *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
2080 /* Clear all the static status flags*/
2081 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2087 * @brief Gets the current sd card data status.
2088 * @param hsd: SD handle
2089 * @retval Data Transfer state
2091 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
2093 HAL_SD_CardStateTypedef cardstate = SD_CARD_TRANSFER;
2095 /* Get SD card state */
2096 cardstate = SD_GetState(hsd);
2098 /* Find SD status according to card state*/
2099 if (cardstate == SD_CARD_TRANSFER)
2101 return SD_TRANSFER_OK;
2103 else if(cardstate == SD_CARD_ERROR)
2105 return SD_TRANSFER_ERROR;
2109 return SD_TRANSFER_BUSY;
2114 * @brief Gets the SD card status.
2115 * @param hsd: SD handle
2116 * @param pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
2117 * will contain the SD card status information
2118 * @retval SD Card error state
2120 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
2122 HAL_SD_ErrorTypedef errorstate = SD_OK;
2124 uint32_t sd_status[16];
2126 errorstate = HAL_SD_SendSDStatus(hsd, sd_status);
2128 if (errorstate != SD_OK)
2134 tmp = (sd_status[0] & 0xC0) >> 6;
2135 pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
2138 tmp = (sd_status[0] & 0x20) >> 5;
2139 pCardStatus->SECURED_MODE = (uint8_t)tmp;
2142 tmp = (sd_status[2] & 0xFF);
2143 pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
2146 tmp = (sd_status[3] & 0xFF);
2147 pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
2150 tmp = (sd_status[4] & 0xFF);
2151 pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
2154 tmp = (sd_status[5] & 0xFF);
2155 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
2158 tmp = (sd_status[6] & 0xFF);
2159 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
2162 tmp = (sd_status[7] & 0xFF);
2163 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
2166 tmp = (sd_status[8] & 0xFF);
2167 pCardStatus->SPEED_CLASS = (uint8_t)tmp;
2170 tmp = (sd_status[9] & 0xFF);
2171 pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
2174 tmp = (sd_status[10] & 0xF0) >> 4;
2175 pCardStatus->AU_SIZE = (uint8_t)tmp;
2178 tmp = (sd_status[11] & 0xFF);
2179 pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
2182 tmp = (sd_status[12] & 0xFF);
2183 pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
2186 tmp = (sd_status[13] & 0xFC) >> 2;
2187 pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
2190 tmp = (sd_status[13] & 0x3);
2191 pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
2204 /* Private function ----------------------------------------------------------*/
2205 /** @addtogroup SD_Private_Functions
2210 * @brief SD DMA transfer complete Rx callback.
2211 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2212 * the configuration information for the specified DMA module.
2215 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
2217 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2219 /* DMA transfer is complete */
2220 hsd->DmaTransferCplt = 1;
2222 /* Wait until SD transfer is complete */
2223 while(hsd->SdTransferCplt == 0)
2227 /* Disable the DMA channel */
2228 HAL_DMA_Abort(hdma);
2230 /* Transfer complete user callback */
2231 HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
2235 * @brief SD DMA transfer Error Rx callback.
2236 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2237 * the configuration information for the specified DMA module.
2240 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
2242 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2244 /* Transfer complete user callback */
2245 HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
2249 * @brief SD DMA transfer complete Tx callback.
2250 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2251 * the configuration information for the specified DMA module.
2254 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
2256 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2258 /* DMA transfer is complete */
2259 hsd->DmaTransferCplt = 1;
2261 /* Wait until SD transfer is complete */
2262 while(hsd->SdTransferCplt == 0)
2266 /* Disable the DMA channel */
2267 HAL_DMA_Abort(hdma);
2269 /* Transfer complete user callback */
2270 HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
2274 * @brief SD DMA transfer Error Tx callback.
2275 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2276 * the configuration information for the specified DMA module.
2279 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
2281 SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
2283 /* Transfer complete user callback */
2284 HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
2288 * @brief Returns the SD current state.
2289 * @param hsd: SD handle
2290 * @retval SD card current state
2292 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
2296 if (SD_SendStatus(hsd, &resp1) != SD_OK)
2298 return SD_CARD_ERROR;
2302 return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
2307 * @brief Initializes all cards or single card as the case may be Card(s) come
2308 * into standby state.
2309 * @param hsd: SD handle
2310 * @retval SD Card error state
2312 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
2314 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2315 HAL_SD_ErrorTypedef errorstate = SD_OK;
2316 uint16_t sd_rca = 1;
2318 if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
2320 errorstate = SD_REQUEST_NOT_APPLICABLE;
2325 if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
2327 /* Send CMD2 ALL_SEND_CID */
2328 sdio_cmdinitstructure.Argument = 0;
2329 sdio_cmdinitstructure.CmdIndex = SD_CMD_ALL_SEND_CID;
2330 sdio_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
2331 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2332 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2333 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2335 /* Check for error conditions */
2336 errorstate = SD_CmdResp2Error(hsd);
2338 if(errorstate != SD_OK)
2343 /* Get Card identification number data */
2344 hsd->CID[0] = SDIO_GetResponse(SDIO_RESP1);
2345 hsd->CID[1] = SDIO_GetResponse(SDIO_RESP2);
2346 hsd->CID[2] = SDIO_GetResponse(SDIO_RESP3);
2347 hsd->CID[3] = SDIO_GetResponse(SDIO_RESP4);
2350 if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
2351 (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
2353 /* Send CMD3 SET_REL_ADDR with argument 0 */
2354 /* SD Card publishes its RCA. */
2355 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_REL_ADDR;
2356 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2357 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2359 /* Check for error conditions */
2360 errorstate = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
2362 if(errorstate != SD_OK)
2368 if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
2370 /* Get the SD card RCA */
2373 /* Send CMD9 SEND_CSD with argument as card's RCA */
2374 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
2375 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_CSD;
2376 sdio_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
2377 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2379 /* Check for error conditions */
2380 errorstate = SD_CmdResp2Error(hsd);
2382 if(errorstate != SD_OK)
2387 /* Get Card Specific Data */
2388 hsd->CSD[0] = SDIO_GetResponse(SDIO_RESP1);
2389 hsd->CSD[1] = SDIO_GetResponse(SDIO_RESP2);
2390 hsd->CSD[2] = SDIO_GetResponse(SDIO_RESP3);
2391 hsd->CSD[3] = SDIO_GetResponse(SDIO_RESP4);
2394 /* All cards are initialized */
2399 * @brief Selects of Deselects the corresponding card.
2400 * @param hsd: SD handle
2401 * @param addr: Address of the card to be selected
2402 * @retval SD Card error state
2404 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
2406 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2407 HAL_SD_ErrorTypedef errorstate = SD_OK;
2409 /* Send CMD7 SDIO_SEL_DESEL_CARD */
2410 sdio_cmdinitstructure.Argument = (uint32_t)addr;
2411 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEL_DESEL_CARD;
2412 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2413 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2414 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2415 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2417 /* Check for error conditions */
2418 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
2424 * @brief Enquires cards about their operating voltage and configures clock
2425 * controls and stores SD information that will be needed in future
2427 * @param hsd: SD handle
2428 * @retval SD Card error state
2430 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
2432 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2433 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
2434 uint32_t response = 0, count = 0, validvoltage = 0;
2435 uint32_t sdtype = SD_STD_CAPACITY;
2437 /* Power ON Sequence -------------------------------------------------------*/
2438 /* Disable SDIO Clock */
2439 __HAL_SD_SDIO_DISABLE();
2441 /* Set Power State to ON */
2442 SDIO_PowerState_ON(hsd->Instance);
2444 /* 1ms: required power up waiting time before starting the SD initialization
2448 /* Enable SDIO Clock */
2449 __HAL_SD_SDIO_ENABLE();
2451 /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
2452 /* No CMD response required */
2453 sdio_cmdinitstructure.Argument = 0;
2454 sdio_cmdinitstructure.CmdIndex = SD_CMD_GO_IDLE_STATE;
2455 sdio_cmdinitstructure.Response = SDIO_RESPONSE_NO;
2456 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2457 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2458 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2460 /* Check for error conditions */
2461 errorstate = SD_CmdError(hsd);
2463 if(errorstate != SD_OK)
2465 /* CMD Response Timeout (wait for CMDSENT flag) */
2469 /* CMD8: SEND_IF_COND ------------------------------------------------------*/
2470 /* Send CMD8 to verify SD card interface operating condition */
2471 /* Argument: - [31:12]: Reserved (shall be set to '0')
2472 - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
2473 - [7:0]: Check Pattern (recommended 0xAA) */
2474 /* CMD Response: R7 */
2475 sdio_cmdinitstructure.Argument = SD_CHECK_PATTERN;
2476 sdio_cmdinitstructure.CmdIndex = SD_SDIO_SEND_IF_COND;
2477 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2478 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2480 /* Check for error conditions */
2481 errorstate = SD_CmdResp7Error(hsd);
2483 if (errorstate == SD_OK)
2486 hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
2487 sdtype = SD_HIGH_CAPACITY;
2491 sdio_cmdinitstructure.Argument = 0;
2492 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
2493 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2495 /* Check for error conditions */
2496 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2498 /* If errorstate is Command Timeout, it is a MMC card */
2499 /* If errorstate is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
2501 if(errorstate == SD_OK)
2504 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2505 while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
2508 /* SEND CMD55 APP_CMD with RCA as 0 */
2509 sdio_cmdinitstructure.Argument = 0;
2510 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
2511 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2512 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2513 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2514 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2516 /* Check for error conditions */
2517 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2519 if(errorstate != SD_OK)
2525 sdio_cmdinitstructure.Argument = SD_VOLTAGE_WINDOW_SD | sdtype;
2526 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_OP_COND;
2527 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2528 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2529 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2530 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2532 /* Check for error conditions */
2533 errorstate = SD_CmdResp3Error(hsd);
2535 if(errorstate != SD_OK)
2540 /* Get command response */
2541 response = SDIO_GetResponse(SDIO_RESP1);
2543 /* Get operating voltage*/
2544 validvoltage = (((response >> 31) == 1) ? 1 : 0);
2549 if(count >= SD_MAX_VOLT_TRIAL)
2551 errorstate = SD_INVALID_VOLTRANGE;
2556 if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2558 hsd->CardType = HIGH_CAPACITY_SD_CARD;
2561 } /* else MMC Card */
2567 * @brief Turns the SDIO output signals off.
2568 * @param hsd: SD handle
2569 * @retval SD Card error state
2571 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
2573 HAL_SD_ErrorTypedef errorstate = SD_OK;
2575 /* Set Power State to OFF */
2576 SDIO_PowerState_OFF(hsd->Instance);
2582 * @brief Returns the current card's status.
2583 * @param hsd: SD handle
2584 * @param pCardStatus: pointer to the buffer that will contain the SD card
2585 * status (Card Status register)
2586 * @retval SD Card error state
2588 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
2590 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2591 HAL_SD_ErrorTypedef errorstate = SD_OK;
2593 if(pCardStatus == NULL)
2595 errorstate = SD_INVALID_PARAMETER;
2600 /* Send Status command */
2601 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
2602 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
2603 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2604 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2605 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2606 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2608 /* Check for error conditions */
2609 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
2611 if(errorstate != SD_OK)
2616 /* Get SD card status */
2617 *pCardStatus = SDIO_GetResponse(SDIO_RESP1);
2623 * @brief Checks for error conditions for CMD0.
2624 * @param hsd: SD handle
2625 * @retval SD Card error state
2627 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
2629 HAL_SD_ErrorTypedef errorstate = SD_OK;
2630 uint32_t timeout, tmp;
2632 timeout = SDIO_CMD0TIMEOUT;
2634 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2636 while((timeout > 0) && (!tmp))
2638 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2644 errorstate = SD_CMD_RSP_TIMEOUT;
2648 /* Clear all the static flags */
2649 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2655 * @brief Checks for error conditions for R7 response.
2656 * @param hsd: SD handle
2657 * @retval SD Card error state
2659 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
2661 HAL_SD_ErrorTypedef errorstate = SD_ERROR;
2662 uint32_t timeout = SDIO_CMD0TIMEOUT, tmp;
2664 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2666 while((!tmp) && (timeout > 0))
2668 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2672 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2674 if((timeout == 0) || tmp)
2676 /* Card is not V2.0 compliant or card does not support the set voltage range */
2677 errorstate = SD_CMD_RSP_TIMEOUT;
2679 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2684 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
2686 /* Card is SD V2.0 compliant */
2689 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
2698 * @brief Checks for error conditions for R1 response.
2699 * @param hsd: SD handle
2700 * @param SD_CMD: The sent command index
2701 * @retval SD Card error state
2703 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
2705 HAL_SD_ErrorTypedef errorstate = SD_OK;
2706 uint32_t response_r1;
2708 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2712 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2714 errorstate = SD_CMD_RSP_TIMEOUT;
2716 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2720 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2722 errorstate = SD_CMD_CRC_FAIL;
2724 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2729 /* Check response received is of desired command */
2730 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2732 errorstate = SD_ILLEGAL_CMD;
2737 /* Clear all the static flags */
2738 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2740 /* We have received response, retrieve it for analysis */
2741 response_r1 = SDIO_GetResponse(SDIO_RESP1);
2743 if((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
2748 if((response_r1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
2750 return(SD_ADDR_OUT_OF_RANGE);
2753 if((response_r1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
2755 return(SD_ADDR_MISALIGNED);
2758 if((response_r1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
2760 return(SD_BLOCK_LEN_ERR);
2763 if((response_r1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
2765 return(SD_ERASE_SEQ_ERR);
2768 if((response_r1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
2770 return(SD_BAD_ERASE_PARAM);
2773 if((response_r1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
2775 return(SD_WRITE_PROT_VIOLATION);
2778 if((response_r1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
2780 return(SD_LOCK_UNLOCK_FAILED);
2783 if((response_r1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
2785 return(SD_COM_CRC_FAILED);
2788 if((response_r1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
2790 return(SD_ILLEGAL_CMD);
2793 if((response_r1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
2795 return(SD_CARD_ECC_FAILED);
2798 if((response_r1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
2800 return(SD_CC_ERROR);
2803 if((response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
2805 return(SD_GENERAL_UNKNOWN_ERROR);
2808 if((response_r1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
2810 return(SD_STREAM_READ_UNDERRUN);
2813 if((response_r1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
2815 return(SD_STREAM_WRITE_OVERRUN);
2818 if((response_r1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
2820 return(SD_CID_CSD_OVERWRITE);
2823 if((response_r1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
2825 return(SD_WP_ERASE_SKIP);
2828 if((response_r1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
2830 return(SD_CARD_ECC_DISABLED);
2833 if((response_r1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
2835 return(SD_ERASE_RESET);
2838 if((response_r1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
2840 return(SD_AKE_SEQ_ERROR);
2847 * @brief Checks for error conditions for R3 (OCR) response.
2848 * @param hsd: SD handle
2849 * @retval SD Card error state
2851 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
2853 HAL_SD_ErrorTypedef errorstate = SD_OK;
2855 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2859 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2861 errorstate = SD_CMD_RSP_TIMEOUT;
2863 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2868 /* Clear all the static flags */
2869 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2875 * @brief Checks for error conditions for R2 (CID or CSD) response.
2876 * @param hsd: SD handle
2877 * @retval SD Card error state
2879 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
2881 HAL_SD_ErrorTypedef errorstate = SD_OK;
2883 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2887 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2889 errorstate = SD_CMD_RSP_TIMEOUT;
2891 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2895 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2897 errorstate = SD_CMD_CRC_FAIL;
2899 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2905 /* No error flag set */
2908 /* Clear all the static flags */
2909 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2915 * @brief Checks for error conditions for R6 (RCA) response.
2916 * @param hsd: SD handle
2917 * @param SD_CMD: The sent command index
2918 * @param pRCA: Pointer to the variable that will contain the SD card relative
2920 * @retval SD Card error state
2922 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
2924 HAL_SD_ErrorTypedef errorstate = SD_OK;
2925 uint32_t response_r1;
2927 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2931 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2933 errorstate = SD_CMD_RSP_TIMEOUT;
2935 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2939 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2941 errorstate = SD_CMD_CRC_FAIL;
2943 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2949 /* No error flag set */
2952 /* Check response received is of desired command */
2953 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2955 errorstate = SD_ILLEGAL_CMD;
2960 /* Clear all the static flags */
2961 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2963 /* We have received response, retrieve it. */
2964 response_r1 = SDIO_GetResponse(SDIO_RESP1);
2966 if((response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
2968 *pRCA = (uint16_t) (response_r1 >> 16);
2973 if((response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
2975 return(SD_GENERAL_UNKNOWN_ERROR);
2978 if((response_r1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
2980 return(SD_ILLEGAL_CMD);
2983 if((response_r1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
2985 return(SD_COM_CRC_FAILED);
2992 * @brief Enables the SDIO wide bus mode.
2993 * @param hsd: SD handle
2994 * @retval SD Card error state
2996 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
2998 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2999 HAL_SD_ErrorTypedef errorstate = SD_OK;
3001 uint32_t scr[2] = {0, 0};
3003 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
3005 errorstate = SD_LOCK_UNLOCK_FAILED;
3010 /* Get SCR Register */
3011 errorstate = SD_FindSCR(hsd, scr);
3013 if(errorstate != SD_OK)
3018 /* If requested card supports wide bus operation */
3019 if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
3021 /* Send CMD55 APP_CMD with argument as card's RCA.*/
3022 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3023 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3024 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3025 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3026 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3027 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3029 /* Check for error conditions */
3030 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3032 if(errorstate != SD_OK)
3037 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
3038 sdio_cmdinitstructure.Argument = 2;
3039 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
3040 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3042 /* Check for error conditions */
3043 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
3045 if(errorstate != SD_OK)
3054 errorstate = SD_REQUEST_NOT_APPLICABLE;
3061 * @brief Disables the SDIO wide bus mode.
3062 * @param hsd: SD handle
3063 * @retval SD Card error state
3065 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd)
3067 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3068 HAL_SD_ErrorTypedef errorstate = SD_OK;
3070 uint32_t scr[2] = {0, 0};
3072 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
3074 errorstate = SD_LOCK_UNLOCK_FAILED;
3079 /* Get SCR Register */
3080 errorstate = SD_FindSCR(hsd, scr);
3082 if(errorstate != SD_OK)
3087 /* If requested card supports 1 bit mode operation */
3088 if((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
3090 /* Send CMD55 APP_CMD with argument as card's RCA */
3091 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3092 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3093 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3094 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3095 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3096 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3098 /* Check for error conditions */
3099 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3101 if(errorstate != SD_OK)
3106 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
3107 sdio_cmdinitstructure.Argument = 0;
3108 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
3109 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3111 /* Check for error conditions */
3112 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
3114 if(errorstate != SD_OK)
3123 errorstate = SD_REQUEST_NOT_APPLICABLE;
3131 * @brief Finds the SD card SCR register value.
3132 * @param hsd: SD handle
3133 * @param pSCR: pointer to the buffer that will contain the SCR value
3134 * @retval SD Card error state
3136 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
3138 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3139 SDIO_DataInitTypeDef sdio_datainitstructure;
3140 HAL_SD_ErrorTypedef errorstate = SD_OK;
3142 uint32_t tempscr[2] = {0, 0};
3144 /* Set Block Size To 8 Bytes */
3145 /* Send CMD55 APP_CMD with argument as card's RCA */
3146 sdio_cmdinitstructure.Argument = (uint32_t)8;
3147 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
3148 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3149 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3150 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3151 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3153 /* Check for error conditions */
3154 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
3156 if(errorstate != SD_OK)
3161 /* Send CMD55 APP_CMD with argument as card's RCA */
3162 sdio_cmdinitstructure.Argument = (uint32_t)((hsd->RCA) << 16);
3163 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3164 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3166 /* Check for error conditions */
3167 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3169 if(errorstate != SD_OK)
3173 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
3174 sdio_datainitstructure.DataLength = 8;
3175 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
3176 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
3177 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
3178 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
3179 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
3181 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
3182 sdio_cmdinitstructure.Argument = 0;
3183 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_SEND_SCR;
3184 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3186 /* Check for error conditions */
3187 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_SEND_SCR);
3189 if(errorstate != SD_OK)
3194 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
3196 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
3198 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
3203 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
3205 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
3207 errorstate = SD_DATA_TIMEOUT;
3211 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
3213 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
3215 errorstate = SD_DATA_CRC_FAIL;
3219 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
3221 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
3223 errorstate = SD_RX_OVERRUN;
3227 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
3229 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
3231 errorstate = SD_START_BIT_ERR;
3237 /* No error flag set */
3240 /* Clear all the static flags */
3241 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
3243 *(pSCR + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) |\
3244 ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
3246 *(pSCR) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) |\
3247 ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
3253 * @brief Checks if the SD card is in programming state.
3254 * @param hsd: SD handle
3255 * @param pStatus: pointer to the variable that will contain the SD card state
3256 * @retval SD Card error state
3258 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus)
3260 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3261 HAL_SD_ErrorTypedef errorstate = SD_OK;
3262 __IO uint32_t responseR1 = 0;
3264 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3265 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
3266 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3267 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3268 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3269 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3271 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
3275 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
3277 errorstate = SD_CMD_RSP_TIMEOUT;
3279 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
3283 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
3285 errorstate = SD_CMD_CRC_FAIL;
3287 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
3293 /* No error flag set */
3296 /* Check response received is of desired command */
3297 if((uint32_t)SDIO_GetCommandResponse(hsd->Instance) != SD_CMD_SEND_STATUS)
3299 errorstate = SD_ILLEGAL_CMD;
3304 /* Clear all the static flags */
3305 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
3308 /* We have received response, retrieve it for analysis */
3309 responseR1 = SDIO_GetResponse(SDIO_RESP1);
3311 /* Find out card status */
3312 *pStatus = (uint8_t)((responseR1 >> 9) & 0x0000000F);
3314 if((responseR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
3319 if((responseR1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
3321 return(SD_ADDR_OUT_OF_RANGE);
3324 if((responseR1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
3326 return(SD_ADDR_MISALIGNED);
3329 if((responseR1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
3331 return(SD_BLOCK_LEN_ERR);
3334 if((responseR1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
3336 return(SD_ERASE_SEQ_ERR);
3339 if((responseR1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
3341 return(SD_BAD_ERASE_PARAM);
3344 if((responseR1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
3346 return(SD_WRITE_PROT_VIOLATION);
3349 if((responseR1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
3351 return(SD_LOCK_UNLOCK_FAILED);
3354 if((responseR1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
3356 return(SD_COM_CRC_FAILED);
3359 if((responseR1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
3361 return(SD_ILLEGAL_CMD);
3364 if((responseR1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
3366 return(SD_CARD_ECC_FAILED);
3369 if((responseR1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
3371 return(SD_CC_ERROR);
3374 if((responseR1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
3376 return(SD_GENERAL_UNKNOWN_ERROR);
3379 if((responseR1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
3381 return(SD_STREAM_READ_UNDERRUN);
3384 if((responseR1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
3386 return(SD_STREAM_WRITE_OVERRUN);
3389 if((responseR1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
3391 return(SD_CID_CSD_OVERWRITE);
3394 if((responseR1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
3396 return(SD_WP_ERASE_SKIP);
3399 if((responseR1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
3401 return(SD_CARD_ECC_DISABLED);
3404 if((responseR1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
3406 return(SD_ERASE_RESET);
3409 if((responseR1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
3411 return(SD_AKE_SEQ_ERROR);
3421 #endif /* HAL_SD_MODULE_ENABLED */
3431 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/