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"
182 #ifdef HAL_SD_MODULE_ENABLED
184 /** @addtogroup STM32F2xx_HAL_Driver
192 /* Private typedef -----------------------------------------------------------*/
193 /* Private define ------------------------------------------------------------*/
194 /** @addtogroup SD_Private_Defines
198 * @brief SDIO Data block size
200 #define DATA_BLOCK_SIZE ((uint32_t)(9 << 4))
202 * @brief SDIO Static flags, Timeout, FIFO Address
204 #define SDIO_STATIC_FLAGS ((uint32_t)(SDIO_FLAG_CCRCFAIL | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_CTIMEOUT |\
205 SDIO_FLAG_DTIMEOUT | SDIO_FLAG_TXUNDERR | SDIO_FLAG_RXOVERR |\
206 SDIO_FLAG_CMDREND | SDIO_FLAG_CMDSENT | SDIO_FLAG_DATAEND |\
209 #define SDIO_CMD0TIMEOUT ((uint32_t)0x00010000)
212 * @brief Mask for errors Card Status R1 (OCR Register)
214 #define SD_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000)
215 #define SD_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000)
216 #define SD_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000)
217 #define SD_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000)
218 #define SD_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000)
219 #define SD_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000)
220 #define SD_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000)
221 #define SD_OCR_COM_CRC_FAILED ((uint32_t)0x00800000)
222 #define SD_OCR_ILLEGAL_CMD ((uint32_t)0x00400000)
223 #define SD_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000)
224 #define SD_OCR_CC_ERROR ((uint32_t)0x00100000)
225 #define SD_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000)
226 #define SD_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000)
227 #define SD_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000)
228 #define SD_OCR_CID_CSD_OVERWRITE ((uint32_t)0x00010000)
229 #define SD_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000)
230 #define SD_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000)
231 #define SD_OCR_ERASE_RESET ((uint32_t)0x00002000)
232 #define SD_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008)
233 #define SD_OCR_ERRORBITS ((uint32_t)0xFDFFE008)
236 * @brief Masks for R6 Response
238 #define SD_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000)
239 #define SD_R6_ILLEGAL_CMD ((uint32_t)0x00004000)
240 #define SD_R6_COM_CRC_FAILED ((uint32_t)0x00008000)
242 #define SD_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000)
243 #define SD_HIGH_CAPACITY ((uint32_t)0x40000000)
244 #define SD_STD_CAPACITY ((uint32_t)0x00000000)
245 #define SD_CHECK_PATTERN ((uint32_t)0x000001AA)
247 #define SD_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFF)
248 #define SD_ALLZERO ((uint32_t)0x00000000)
250 #define SD_WIDE_BUS_SUPPORT ((uint32_t)0x00040000)
251 #define SD_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000)
252 #define SD_CARD_LOCKED ((uint32_t)0x02000000)
254 #define SD_DATATIMEOUT ((uint32_t)0xFFFFFFFF)
255 #define SD_0TO7BITS ((uint32_t)0x000000FF)
256 #define SD_8TO15BITS ((uint32_t)0x0000FF00)
257 #define SD_16TO23BITS ((uint32_t)0x00FF0000)
258 #define SD_24TO31BITS ((uint32_t)0xFF000000)
259 #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFF)
261 #define SD_HALFFIFO ((uint32_t)0x00000008)
262 #define SD_HALFFIFOBYTES ((uint32_t)0x00000020)
265 * @brief Command Class Supported
267 #define SD_CCCC_LOCK_UNLOCK ((uint32_t)0x00000080)
268 #define SD_CCCC_WRITE_PROT ((uint32_t)0x00000040)
269 #define SD_CCCC_ERASE ((uint32_t)0x00000020)
272 * @brief Following commands are SD Card Specific commands.
273 * SDIO_APP_CMD should be sent before sending these commands.
275 #define SD_SDIO_SEND_IF_COND ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
281 /* Private macro -------------------------------------------------------------*/
282 /* Private variables ---------------------------------------------------------*/
283 /* Private function prototypes -----------------------------------------------*/
284 /** @addtogroup SD_Private_Functions_Prototypes
287 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
288 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
289 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd);
290 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
291 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
292 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
293 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
294 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
295 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
296 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
297 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
298 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
299 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
300 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
301 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
302 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
303 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
304 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
305 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
306 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
310 /* Exported functions --------------------------------------------------------*/
311 /** @addtogroup SD_Exported_Functions
315 /** @addtogroup SD_Exported_Functions_Group1
316 * @brief Initialization and de-initialization functions
319 ==============================================================================
320 ##### Initialization and de-initialization functions #####
321 ==============================================================================
323 This section provides functions allowing to initialize/de-initialize the SD
324 card device to be ready for use.
332 * @brief Initializes the SD card according to the specified parameters in the
333 SD_HandleTypeDef and create the associated handle.
334 * @param hsd: SD handle
335 * @param SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information
336 * @retval HAL SD error state
338 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
340 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
341 SD_InitTypeDef tmpinit;
343 /* Allocate lock resource and initialize it */
344 hsd->Lock = HAL_UNLOCKED;
345 /* Initialize the low level hardware (MSP) */
348 /* Default SDIO peripheral configuration for SD card initialization */
349 tmpinit.ClockEdge = SDIO_CLOCK_EDGE_RISING;
350 tmpinit.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
351 tmpinit.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
352 tmpinit.BusWide = SDIO_BUS_WIDE_1B;
353 tmpinit.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
354 tmpinit.ClockDiv = SDIO_INIT_CLK_DIV;
356 /* Initialize SDIO peripheral interface with default configuration */
357 SDIO_Init(hsd->Instance, tmpinit);
359 /* Identify card operating voltage */
360 errorstate = SD_PowerON(hsd);
362 if(errorstate != SD_OK)
367 /* Initialize the present SDIO card(s) and put them in idle state */
368 errorstate = SD_Initialize_Cards(hsd);
370 if (errorstate != SD_OK)
375 /* Read CSD/CID MSD registers */
376 errorstate = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
378 if (errorstate == SD_OK)
380 /* Select the Card */
381 errorstate = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
384 /* Configure SDIO peripheral interface */
385 SDIO_Init(hsd->Instance, hsd->Init);
391 * @brief De-Initializes the SD card.
392 * @param hsd: SD handle
395 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
398 /* Set SD power state to off */
401 /* De-Initialize the MSP layer */
402 HAL_SD_MspDeInit(hsd);
409 * @brief Initializes the SD MSP.
410 * @param hsd: SD handle
413 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
415 /* NOTE : This function Should not be modified, when the callback is needed,
416 the HAL_SD_MspInit could be implemented in the user file
421 * @brief De-Initialize SD MSP.
422 * @param hsd: SD handle
425 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
427 /* NOTE : This function Should not be modified, when the callback is needed,
428 the HAL_SD_MspDeInit could be implemented in the user file
436 /** @addtogroup SD_Exported_Functions_Group2
437 * @brief Data transfer functions
440 ==============================================================================
441 ##### IO operation functions #####
442 ==============================================================================
444 This subsection provides a set of functions allowing to manage the data
445 transfer from/to SD card.
452 * @brief Reads block(s) from a specified address in a card. The Data transfer
453 * is managed by polling mode.
454 * @param hsd: SD handle
455 * @param pReadBuffer: pointer to the buffer that will contain the received data
456 * @param ReadAddr: Address from where data is to be read
457 * @param BlockSize: SD card Data block size
458 * @note BlockSize must be 512 bytes.
459 * @param NumberOfBlocks: Number of SD blocks to read
460 * @retval SD Card error state
462 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
464 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
465 SDIO_DataInitTypeDef sdio_datainitstructure;
466 HAL_SD_ErrorTypedef errorstate = SD_OK;
467 uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
469 /* Initialize data control register */
470 hsd->Instance->DCTRL = 0;
472 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
478 /* Set Block Size for Card */
479 sdio_cmdinitstructure.Argument = (uint32_t) BlockSize;
480 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
481 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
482 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
483 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
484 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
486 /* Check for error conditions */
487 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
489 if (errorstate != SD_OK)
494 /* Configure the SD DPSM (Data Path State Machine) */
495 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
496 sdio_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
497 sdio_datainitstructure.DataBlockSize = DATA_BLOCK_SIZE;
498 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
499 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
500 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
501 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
503 if(NumberOfBlocks > 1)
505 /* Send CMD18 READ_MULT_BLOCK with argument data address */
506 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
510 /* Send CMD17 READ_SINGLE_BLOCK */
511 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
514 sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
515 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
517 /* Read block(s) in polling mode */
518 if(NumberOfBlocks > 1)
520 /* Check for error conditions */
521 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
523 if (errorstate != SD_OK)
528 /* Poll on SDIO flags */
529 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
531 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
533 /* Read data from SDIO Rx FIFO */
534 for (count = 0; count < 8; count++)
536 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
545 /* Check for error conditions */
546 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
548 if (errorstate != SD_OK)
553 /* In case of single block transfer, no need of stop transfer at all */
554 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
556 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
558 /* Read data from SDIO Rx FIFO */
559 for (count = 0; count < 8; count++)
561 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
569 /* Send stop transmission command in case of multiblock read */
570 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
572 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
573 (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
574 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
576 /* Send stop transmission command */
577 errorstate = HAL_SD_StopTransfer(hsd);
581 /* Get error state */
582 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
584 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
586 errorstate = SD_DATA_TIMEOUT;
590 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
592 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
594 errorstate = SD_DATA_CRC_FAIL;
598 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
600 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
602 errorstate = SD_RX_OVERRUN;
606 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
608 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
610 errorstate = SD_START_BIT_ERR;
616 /* No error flag set */
619 count = SD_DATATIMEOUT;
621 /* Empty FIFO if there is still any data */
622 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
624 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
629 /* Clear all the static flags */
630 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
636 * @brief Allows to write block(s) to a specified address in a card. The Data
637 * transfer is managed by polling mode.
638 * @param hsd: SD handle
639 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
640 * @param WriteAddr: Address from where data is to be written
641 * @param BlockSize: SD card Data block size
642 * @note BlockSize must be 512 bytes.
643 * @param NumberOfBlocks: Number of SD blocks to write
644 * @retval SD Card error state
646 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
648 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
649 SDIO_DataInitTypeDef sdio_datainitstructure;
650 HAL_SD_ErrorTypedef errorstate = SD_OK;
651 uint32_t totalnumberofbytes = 0, bytestransferred = 0, count = 0, restwords = 0;
652 uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
653 uint8_t cardstate = 0;
655 /* Initialize data control register */
656 hsd->Instance->DCTRL = 0;
658 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
664 /* Set Block Size for Card */
665 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
666 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
667 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
668 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
669 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
670 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
672 /* Check for error conditions */
673 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
675 if (errorstate != SD_OK)
680 if(NumberOfBlocks > 1)
682 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
683 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
687 /* Send CMD24 WRITE_SINGLE_BLOCK */
688 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
691 sdio_cmdinitstructure.Argument = (uint32_t)WriteAddr;
692 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
694 /* Check for error conditions */
695 if(NumberOfBlocks > 1)
697 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
701 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
704 if (errorstate != SD_OK)
709 /* Set total number of bytes to write */
710 totalnumberofbytes = NumberOfBlocks * BlockSize;
712 /* Configure the SD DPSM (Data Path State Machine) */
713 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
714 sdio_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
715 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
716 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
717 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
718 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
719 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
721 /* Write block(s) in polling mode */
722 if(NumberOfBlocks > 1)
724 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
726 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
728 if ((totalnumberofbytes - bytestransferred) < 32)
730 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
732 /* Write data to SDIO Tx FIFO */
733 for (count = 0; count < restwords; count++)
735 SDIO_WriteFIFO(hsd->Instance, tempbuff);
737 bytestransferred += 4;
742 /* Write data to SDIO Tx FIFO */
743 for (count = 0; count < 8; count++)
745 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
749 bytestransferred += 32;
756 /* In case of single data block transfer no need of stop command at all */
757 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
759 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
761 if ((totalnumberofbytes - bytestransferred) < 32)
763 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
765 /* Write data to SDIO Tx FIFO */
766 for (count = 0; count < restwords; count++)
768 SDIO_WriteFIFO(hsd->Instance, tempbuff);
770 bytestransferred += 4;
775 /* Write data to SDIO Tx FIFO */
776 for (count = 0; count < 8; count++)
778 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
782 bytestransferred += 32;
788 /* Send stop transmission command in case of multiblock write */
789 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
791 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
792 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
794 /* Send stop transmission command */
795 errorstate = HAL_SD_StopTransfer(hsd);
799 /* Get error state */
800 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
802 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
804 errorstate = SD_DATA_TIMEOUT;
808 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
810 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
812 errorstate = SD_DATA_CRC_FAIL;
816 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
818 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
820 errorstate = SD_TX_UNDERRUN;
824 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
826 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
828 errorstate = SD_START_BIT_ERR;
834 /* No error flag set */
837 /* Clear all the static flags */
838 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
840 /* Wait till the card is in programming state */
841 errorstate = SD_IsCardProgramming(hsd, &cardstate);
843 while ((errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
845 errorstate = SD_IsCardProgramming(hsd, &cardstate);
852 * @brief Reads block(s) from a specified address in a card. The Data transfer
853 * is managed by DMA mode.
854 * @note This API should be followed by the function HAL_SD_CheckReadOperation()
855 * to check the completion of the read process
856 * @param hsd: SD handle
857 * @param pReadBuffer: Pointer to the buffer that will contain the received data
858 * @param ReadAddr: Address from where data is to be read
859 * @param BlockSize: SD card Data block size
860 * @note BlockSize must be 512 bytes.
861 * @param NumberOfBlocks: Number of blocks to read.
862 * @retval SD Card error state
864 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
866 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
867 SDIO_DataInitTypeDef sdio_datainitstructure;
868 HAL_SD_ErrorTypedef errorstate = SD_OK;
870 /* Initialize data control register */
871 hsd->Instance->DCTRL = 0;
873 /* Initialize handle flags */
874 hsd->SdTransferCplt = 0;
875 hsd->DmaTransferCplt = 0;
876 hsd->SdTransferErr = SD_OK;
878 /* Initialize SD Read operation */
879 if(NumberOfBlocks > 1)
881 hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
885 hsd->SdOperation = SD_READ_SINGLE_BLOCK;
888 /* Enable transfer interrupts */
889 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
895 /* Enable SDIO DMA transfer */
896 __HAL_SD_SDIO_DMA_ENABLE();
898 /* Configure DMA user callbacks */
899 hsd->hdmarx->XferCpltCallback = SD_DMA_RxCplt;
900 hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
902 /* Enable the DMA Stream */
903 HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks)/4);
905 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
911 /* Set Block Size for Card */
912 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
913 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
914 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
915 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
916 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
917 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
919 /* Check for error conditions */
920 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
922 if (errorstate != SD_OK)
927 /* Configure the SD DPSM (Data Path State Machine) */
928 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
929 sdio_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
930 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
931 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
932 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
933 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
934 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
936 /* Check number of blocks command */
937 if(NumberOfBlocks > 1)
939 /* Send CMD18 READ_MULT_BLOCK with argument data address */
940 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
944 /* Send CMD17 READ_SINGLE_BLOCK */
945 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
948 sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
949 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
951 /* Check for error conditions */
952 if(NumberOfBlocks > 1)
954 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
958 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
961 /* Update the SD transfer error in SD handle */
962 hsd->SdTransferErr = errorstate;
969 * @brief Writes block(s) to a specified address in a card. The Data transfer
970 * is managed by DMA mode.
971 * @note This API should be followed by the function HAL_SD_CheckWriteOperation()
972 * to check the completion of the write process (by SD current status polling).
973 * @param hsd: SD handle
974 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
975 * @param WriteAddr: Address from where data is to be read
976 * @param BlockSize: the SD card Data block size
977 * @note BlockSize must be 512 bytes.
978 * @param NumberOfBlocks: Number of blocks to write
979 * @retval SD Card error state
981 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
983 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
984 SDIO_DataInitTypeDef sdio_datainitstructure;
985 HAL_SD_ErrorTypedef errorstate = SD_OK;
987 /* Initialize data control register */
988 hsd->Instance->DCTRL = 0;
990 /* Initialize handle flags */
991 hsd->SdTransferCplt = 0;
992 hsd->DmaTransferCplt = 0;
993 hsd->SdTransferErr = SD_OK;
995 /* Initialize SD Write operation */
996 if(NumberOfBlocks > 1)
998 hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
1002 hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
1005 /* Enable transfer interrupts */
1006 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
1012 /* Configure DMA user callbacks */
1013 hsd->hdmatx->XferCpltCallback = SD_DMA_TxCplt;
1014 hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
1016 /* Enable the DMA Stream */
1017 HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BlockSize * NumberOfBlocks)/4);
1019 /* Enable SDIO DMA transfer */
1020 __HAL_SD_SDIO_DMA_ENABLE();
1022 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1028 /* Set Block Size for Card */
1029 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
1030 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1031 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1032 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1033 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1034 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1036 /* Check for error conditions */
1037 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1039 if (errorstate != SD_OK)
1044 /* Check number of blocks command */
1045 if(NumberOfBlocks <= 1)
1047 /* Send CMD24 WRITE_SINGLE_BLOCK */
1048 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
1052 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
1053 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
1056 sdio_cmdinitstructure.Argument = (uint32_t)WriteAddr;
1057 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1059 /* Check for error conditions */
1060 if(NumberOfBlocks > 1)
1062 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
1066 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
1069 if (errorstate != SD_OK)
1074 /* Configure the SD DPSM (Data Path State Machine) */
1075 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
1076 sdio_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
1077 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1078 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1079 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1080 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
1081 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1083 hsd->SdTransferErr = errorstate;
1089 * @brief This function waits until the SD DMA data read transfer is finished.
1090 * This API should be called after HAL_SD_ReadBlocks_DMA() function
1091 * to insure that all data sent by the card is already transferred by the
1093 * @param hsd: SD handle
1094 * @param Timeout: Timeout duration
1095 * @retval SD Card error state
1097 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1099 HAL_SD_ErrorTypedef errorstate = SD_OK;
1100 uint32_t timeout = Timeout;
1101 uint32_t tmp1, tmp2;
1102 HAL_SD_ErrorTypedef tmp3;
1104 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1105 tmp1 = hsd->DmaTransferCplt;
1106 tmp2 = hsd->SdTransferCplt;
1107 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1109 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1111 tmp1 = hsd->DmaTransferCplt;
1112 tmp2 = hsd->SdTransferCplt;
1113 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1119 /* Wait until the Rx transfer is no longer active. IE. fifo is empty.
1120 Once FIFO is empty, the DMA will have finished and DmaTransferCplt should
1122 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXACT)) && (timeout > 0))
1127 /* Send stop command in multiblock read */
1128 if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
1130 errorstate = HAL_SD_StopTransfer(hsd);
1133 if ((timeout == 0) && (errorstate == SD_OK))
1135 errorstate = SD_DATA_TIMEOUT;
1138 /* Clear all the static flags */
1139 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1141 /* Return error state */
1142 if (hsd->SdTransferErr != SD_OK)
1144 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1151 * @brief This function waits until the SD DMA data write transfer is finished.
1152 * This API should be called after HAL_SD_WriteBlocks_DMA() function
1153 * to insure that all data sent by the card is already transferred by the
1155 * @param hsd: SD handle
1156 * @param Timeout: Timeout duration
1157 * @retval SD Card error state
1159 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1161 HAL_SD_ErrorTypedef errorstate = SD_OK;
1162 uint32_t timeout = Timeout;
1163 uint32_t tmp1, tmp2;
1164 HAL_SD_ErrorTypedef tmp3;
1166 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1167 tmp1 = hsd->DmaTransferCplt;
1168 tmp2 = hsd->SdTransferCplt;
1169 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1171 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1173 tmp1 = hsd->DmaTransferCplt;
1174 tmp2 = hsd->SdTransferCplt;
1175 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1181 /* Wait until the Tx transfer is no longer active */
1182 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXACT)) && (timeout > 0))
1187 /* Send stop command in multiblock write */
1188 if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
1190 errorstate = HAL_SD_StopTransfer(hsd);
1193 if ((timeout == 0) && (errorstate == SD_OK))
1195 errorstate = SD_DATA_TIMEOUT;
1198 /* Clear all the static flags */
1199 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1201 /* Return error state */
1202 if (hsd->SdTransferErr != SD_OK)
1204 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1207 /* Wait until write is complete */
1208 while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
1216 * @brief Erases the specified memory area of the given SD card.
1217 * @param hsd: SD handle
1218 * @param startaddr: Start byte address
1219 * @param endaddr: End byte address
1220 * @retval SD Card error state
1222 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
1224 HAL_SD_ErrorTypedef errorstate = SD_OK;
1225 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1228 __IO uint32_t maxdelay = 0;
1229 uint8_t cardstate = 0;
1231 /* Check if the card command class supports erase command */
1232 if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
1234 errorstate = SD_REQUEST_NOT_APPLICABLE;
1239 /* Get max delay value */
1240 maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
1242 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1244 errorstate = SD_LOCK_UNLOCK_FAILED;
1249 /* Get start and end block for high capacity cards */
1250 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1256 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1257 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1258 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1260 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
1261 sdio_cmdinitstructure.Argument =(uint32_t)startaddr;
1262 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_START;
1263 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1264 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1265 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1266 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1268 /* Check for error conditions */
1269 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
1271 if (errorstate != SD_OK)
1276 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
1277 sdio_cmdinitstructure.Argument = (uint32_t)endaddr;
1278 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_END;
1279 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1281 /* Check for error conditions */
1282 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
1284 if (errorstate != SD_OK)
1290 /* Send CMD38 ERASE */
1291 sdio_cmdinitstructure.Argument = 0;
1292 sdio_cmdinitstructure.CmdIndex = SD_CMD_ERASE;
1293 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1295 /* Check for error conditions */
1296 errorstate = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
1298 if (errorstate != SD_OK)
1303 for (; delay < maxdelay; delay++)
1307 /* Wait until the card is in programming state */
1308 errorstate = SD_IsCardProgramming(hsd, &cardstate);
1310 delay = SD_DATATIMEOUT;
1312 while ((delay > 0) && (errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
1314 errorstate = SD_IsCardProgramming(hsd, &cardstate);
1322 * @brief This function handles SD card interrupt request.
1323 * @param hsd: SD handle
1326 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1328 /* Check for SDIO interrupt flags */
1329 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DATAEND))
1331 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_IT_DATAEND);
1333 /* SD transfer is complete */
1334 hsd->SdTransferCplt = 1;
1336 /* No transfer error */
1337 hsd->SdTransferErr = SD_OK;
1339 HAL_SD_XferCpltCallback(hsd);
1341 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DCRCFAIL))
1343 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1345 hsd->SdTransferErr = SD_DATA_CRC_FAIL;
1347 HAL_SD_XferErrorCallback(hsd);
1350 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DTIMEOUT))
1352 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1354 hsd->SdTransferErr = SD_DATA_TIMEOUT;
1356 HAL_SD_XferErrorCallback(hsd);
1358 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_RXOVERR))
1360 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1362 hsd->SdTransferErr = SD_RX_OVERRUN;
1364 HAL_SD_XferErrorCallback(hsd);
1366 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_TXUNDERR))
1368 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
1370 hsd->SdTransferErr = SD_TX_UNDERRUN;
1372 HAL_SD_XferErrorCallback(hsd);
1374 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_STBITERR))
1376 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1378 hsd->SdTransferErr = SD_START_BIT_ERR;
1380 HAL_SD_XferErrorCallback(hsd);
1384 /* No error flag set */
1387 /* Disable all SDIO peripheral interrupt sources */
1388 __HAL_SD_SDIO_DISABLE_IT(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |\
1389 SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |\
1390 SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1395 * @brief SD end of transfer callback.
1396 * @param hsd: SD handle
1399 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
1401 /* NOTE : This function Should not be modified, when the callback is needed,
1402 the HAL_SD_XferCpltCallback could be implemented in the user file
1407 * @brief SD Transfer Error callback.
1408 * @param hsd: SD handle
1411 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
1413 /* NOTE : This function Should not be modified, when the callback is needed,
1414 the HAL_SD_XferErrorCallback could be implemented in the user file
1419 * @brief SD Transfer complete Rx callback in non blocking mode.
1420 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1421 * the configuration information for the specified DMA module.
1424 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
1426 /* NOTE : This function Should not be modified, when the callback is needed,
1427 the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
1432 * @brief SD DMA transfer complete Rx error callback.
1433 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1434 * the configuration information for the specified DMA module.
1437 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
1439 /* NOTE : This function Should not be modified, when the callback is needed,
1440 the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
1445 * @brief SD Transfer complete Tx callback in non blocking mode.
1446 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1447 * the configuration information for the specified DMA module.
1450 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
1452 /* NOTE : This function Should not be modified, when the callback is needed,
1453 the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
1458 * @brief SD DMA transfer complete error Tx callback.
1459 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1460 * the configuration information for the specified DMA module.
1463 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
1465 /* NOTE : This function Should not be modified, when the callback is needed,
1466 the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
1474 /** @addtogroup SD_Exported_Functions_Group3
1475 * @brief management functions
1478 ==============================================================================
1479 ##### Peripheral Control functions #####
1480 ==============================================================================
1482 This subsection provides a set of functions allowing to control the SD card
1490 * @brief Returns information about specific card.
1491 * @param hsd: SD handle
1492 * @param pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
1493 * contains all SD cardinformation
1494 * @retval SD Card error state
1496 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
1498 HAL_SD_ErrorTypedef errorstate = SD_OK;
1501 pCardInfo->CardType = (uint8_t)(hsd->CardType);
1502 pCardInfo->RCA = (uint16_t)(hsd->RCA);
1505 tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
1506 pCardInfo->SD_csd.CSDStruct = (uint8_t)((tmp & 0xC0) >> 6);
1507 pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
1508 pCardInfo->SD_csd.Reserved1 = tmp & 0x03;
1511 tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
1512 pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
1515 tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
1516 pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
1519 tmp = hsd->CSD[0] & 0x000000FF;
1520 pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
1523 tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
1524 pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
1527 tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
1528 pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
1529 pCardInfo->SD_csd.RdBlockLen = (uint8_t)(tmp & 0x0F);
1532 tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
1533 pCardInfo->SD_csd.PartBlockRead = (uint8_t)((tmp & 0x80) >> 7);
1534 pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
1535 pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
1536 pCardInfo->SD_csd.DSRImpl = (uint8_t)((tmp & 0x10) >> 4);
1537 pCardInfo->SD_csd.Reserved2 = 0; /*!< Reserved */
1539 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
1541 pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
1544 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1545 pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
1548 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1549 pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
1551 pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
1552 pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
1555 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1556 pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
1557 pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
1558 pCardInfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
1560 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1561 pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
1563 pCardInfo->CardCapacity = (pCardInfo->SD_csd.DeviceSize + 1) ;
1564 pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
1565 pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
1566 pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
1568 else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1571 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1572 pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
1575 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1577 pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
1580 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1582 pCardInfo->SD_csd.DeviceSize |= (tmp);
1585 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1587 pCardInfo->CardCapacity = (uint64_t)((((uint64_t)pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024);
1588 pCardInfo->CardBlockSize = 512;
1592 /* Not supported card type */
1593 errorstate = SD_ERROR;
1596 pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
1597 pCardInfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
1600 tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
1601 pCardInfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
1602 pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
1605 tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
1606 pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
1607 pCardInfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
1608 pCardInfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
1609 pCardInfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
1612 tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
1613 pCardInfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
1614 pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
1615 pCardInfo->SD_csd.Reserved3 = 0;
1616 pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
1619 tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
1620 pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
1621 pCardInfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
1622 pCardInfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
1623 pCardInfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
1624 pCardInfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
1625 pCardInfo->SD_csd.ECC = (tmp & 0x03);
1628 tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
1629 pCardInfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
1630 pCardInfo->SD_csd.Reserved4 = 1;
1633 tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
1634 pCardInfo->SD_cid.ManufacturerID = tmp;
1637 tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
1638 pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
1641 tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
1642 pCardInfo->SD_cid.OEM_AppliID |= tmp;
1645 tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
1646 pCardInfo->SD_cid.ProdName1 = tmp << 24;
1649 tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
1650 pCardInfo->SD_cid.ProdName1 |= tmp << 16;
1653 tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
1654 pCardInfo->SD_cid.ProdName1 |= tmp << 8;
1657 tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
1658 pCardInfo->SD_cid.ProdName1 |= tmp;
1661 tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
1662 pCardInfo->SD_cid.ProdName2 = tmp;
1665 tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
1666 pCardInfo->SD_cid.ProdRev = tmp;
1669 tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
1670 pCardInfo->SD_cid.ProdSN = tmp << 24;
1673 tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
1674 pCardInfo->SD_cid.ProdSN |= tmp << 16;
1677 tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
1678 pCardInfo->SD_cid.ProdSN |= tmp << 8;
1681 tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
1682 pCardInfo->SD_cid.ProdSN |= tmp;
1685 tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
1686 pCardInfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
1687 pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
1690 tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
1691 pCardInfo->SD_cid.ManufactDate |= tmp;
1694 tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
1695 pCardInfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
1696 pCardInfo->SD_cid.Reserved2 = 1;
1702 * @brief Enables wide bus operation for the requested card if supported by
1704 * @param hsd: SD handle
1705 * @param WideMode: Specifies the SD card wide bus mode
1706 * This parameter can be one of the following values:
1707 * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
1708 * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
1709 * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
1710 * @retval SD Card error state
1712 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
1714 HAL_SD_ErrorTypedef errorstate = SD_OK;
1715 SDIO_InitTypeDef tmpinit;
1717 /* MMC Card does not support this feature */
1718 if (hsd->CardType == MULTIMEDIA_CARD)
1720 errorstate = SD_UNSUPPORTED_FEATURE;
1724 else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1725 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1727 if (WideMode == SDIO_BUS_WIDE_8B)
1729 errorstate = SD_UNSUPPORTED_FEATURE;
1731 else if (WideMode == SDIO_BUS_WIDE_4B)
1733 errorstate = SD_WideBus_Enable(hsd);
1735 else if (WideMode == SDIO_BUS_WIDE_1B)
1737 errorstate = SD_WideBus_Disable(hsd);
1741 /* WideMode is not a valid argument*/
1742 errorstate = SD_INVALID_PARAMETER;
1745 if (errorstate == SD_OK)
1747 /* Configure the SDIO peripheral */
1748 tmpinit.ClockEdge = hsd->Init.ClockEdge;
1749 tmpinit.ClockBypass = hsd->Init.ClockBypass;
1750 tmpinit.ClockPowerSave = hsd->Init.ClockPowerSave;
1751 tmpinit.BusWide = WideMode;
1752 tmpinit.HardwareFlowControl = hsd->Init.HardwareFlowControl;
1753 tmpinit.ClockDiv = hsd->Init.ClockDiv;
1754 SDIO_Init(hsd->Instance, tmpinit);
1762 * @brief Aborts an ongoing data transfer.
1763 * @param hsd: SD handle
1764 * @retval SD Card error state
1766 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
1768 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1769 HAL_SD_ErrorTypedef errorstate = SD_OK;
1771 /* Send CMD12 STOP_TRANSMISSION */
1772 sdio_cmdinitstructure.Argument = 0;
1773 sdio_cmdinitstructure.CmdIndex = SD_CMD_STOP_TRANSMISSION;
1774 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1775 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1776 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1777 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1779 /* Check for error conditions */
1780 errorstate = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
1786 * @brief Switches the SD card to High Speed mode.
1787 * This API must be used after "Transfer State"
1788 * @note This operation should be followed by the configuration
1789 * of PLL to have SDIOCK clock between 67 and 75 MHz
1790 * @param hsd: SD handle
1791 * @retval SD Card error state
1793 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
1795 HAL_SD_ErrorTypedef errorstate = SD_OK;
1796 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1797 SDIO_DataInitTypeDef sdio_datainitstructure;
1799 uint8_t SD_hs[64] = {0};
1800 uint32_t SD_scr[2] = {0, 0};
1801 uint32_t SD_SPEC = 0 ;
1802 uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
1804 /* Initialize the Data control register */
1805 hsd->Instance->DCTRL = 0;
1807 /* Get SCR Register */
1808 errorstate = SD_FindSCR(hsd, SD_scr);
1810 if (errorstate != SD_OK)
1815 /* Test the Version supported by the card*/
1816 SD_SPEC = (SD_scr[1] & 0x01000000) | (SD_scr[1] & 0x02000000);
1818 if (SD_SPEC != SD_ALLZERO)
1820 /* Set Block Size for Card */
1821 sdio_cmdinitstructure.Argument = (uint32_t)64;
1822 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1823 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1824 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1825 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1826 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1828 /* Check for error conditions */
1829 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1831 if (errorstate != SD_OK)
1836 /* Configure the SD DPSM (Data Path State Machine) */
1837 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
1838 sdio_datainitstructure.DataLength = 64;
1839 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
1840 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1841 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1842 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
1843 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1845 /* Send CMD6 switch mode */
1846 sdio_cmdinitstructure.Argument = 0x80FFFF01;
1847 sdio_cmdinitstructure.CmdIndex = SD_CMD_HS_SWITCH;
1848 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1850 /* Check for error conditions */
1851 errorstate = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
1853 if (errorstate != SD_OK)
1858 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
1860 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
1862 for (count = 0; count < 8; count++)
1864 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
1871 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
1873 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1875 errorstate = SD_DATA_TIMEOUT;
1879 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
1881 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1883 errorstate = SD_DATA_CRC_FAIL;
1887 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
1889 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1891 errorstate = SD_RX_OVERRUN;
1895 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
1897 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1899 errorstate = SD_START_BIT_ERR;
1905 /* No error flag set */
1908 count = SD_DATATIMEOUT;
1910 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
1912 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
1917 /* Clear all the static flags */
1918 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1920 /* Test if the switch mode HS is ok */
1921 if ((SD_hs[13]& 2) != 2)
1923 errorstate = SD_UNSUPPORTED_FEATURE;
1934 /** @addtogroup SD_Exported_Functions_Group4
1935 * @brief Peripheral State functions
1938 ==============================================================================
1939 ##### Peripheral State functions #####
1940 ==============================================================================
1942 This subsection permits to get in runtime the status of the peripheral
1950 * @brief Returns the current SD card's status.
1951 * @param hsd: SD handle
1952 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
1953 * SD Status register)
1954 * @retval SD Card error state
1956 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
1958 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1959 SDIO_DataInitTypeDef sdio_datainitstructure;
1960 HAL_SD_ErrorTypedef errorstate = SD_OK;
1963 /* Check SD response */
1964 if ((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1966 errorstate = SD_LOCK_UNLOCK_FAILED;
1971 /* Set block size for card if it is not equal to current block size for card */
1972 sdio_cmdinitstructure.Argument = 64;
1973 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1974 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1975 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1976 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1977 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1979 /* Check for error conditions */
1980 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1982 if (errorstate != SD_OK)
1988 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
1989 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
1990 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1992 /* Check for error conditions */
1993 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
1995 if (errorstate != SD_OK)
2000 /* Configure the SD DPSM (Data Path State Machine) */
2001 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
2002 sdio_datainitstructure.DataLength = 64;
2003 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
2004 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
2005 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
2006 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
2007 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
2009 /* Send ACMD13 (SD_APP_STATUS) with argument as card's RCA */
2010 sdio_cmdinitstructure.Argument = 0;
2011 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_STATUS;
2012 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2014 /* Check for error conditions */
2015 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STATUS);
2017 if (errorstate != SD_OK)
2022 /* Get status data */
2023 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
2025 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2027 for (count = 0; count < 8; count++)
2029 *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
2036 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
2038 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
2040 errorstate = SD_DATA_TIMEOUT;
2044 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2046 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
2048 errorstate = SD_DATA_CRC_FAIL;
2052 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2054 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
2056 errorstate = SD_RX_OVERRUN;
2060 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
2062 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
2064 errorstate = SD_START_BIT_ERR;
2070 /* No error flag set */
2073 count = SD_DATATIMEOUT;
2074 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
2076 *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
2081 /* Clear all the static status flags*/
2082 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2088 * @brief Gets the current sd card data status.
2089 * @param hsd: SD handle
2090 * @retval Data Transfer state
2092 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
2094 HAL_SD_CardStateTypedef cardstate = SD_CARD_TRANSFER;
2096 /* Get SD card state */
2097 cardstate = SD_GetState(hsd);
2099 /* Find SD status according to card state*/
2100 if (cardstate == SD_CARD_TRANSFER)
2102 return SD_TRANSFER_OK;
2104 else if(cardstate == SD_CARD_ERROR)
2106 return SD_TRANSFER_ERROR;
2110 return SD_TRANSFER_BUSY;
2115 * @brief Gets the SD card status.
2116 * @param hsd: SD handle
2117 * @param pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
2118 * will contain the SD card status information
2119 * @retval SD Card error state
2121 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
2123 HAL_SD_ErrorTypedef errorstate = SD_OK;
2125 uint32_t sd_status[16];
2127 errorstate = HAL_SD_SendSDStatus(hsd, sd_status);
2129 if (errorstate != SD_OK)
2135 tmp = (sd_status[0] & 0xC0) >> 6;
2136 pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
2139 tmp = (sd_status[0] & 0x20) >> 5;
2140 pCardStatus->SECURED_MODE = (uint8_t)tmp;
2143 tmp = (sd_status[2] & 0xFF);
2144 pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
2147 tmp = (sd_status[3] & 0xFF);
2148 pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
2151 tmp = (sd_status[4] & 0xFF);
2152 pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
2155 tmp = (sd_status[5] & 0xFF);
2156 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
2159 tmp = (sd_status[6] & 0xFF);
2160 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
2163 tmp = (sd_status[7] & 0xFF);
2164 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
2167 tmp = (sd_status[8] & 0xFF);
2168 pCardStatus->SPEED_CLASS = (uint8_t)tmp;
2171 tmp = (sd_status[9] & 0xFF);
2172 pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
2175 tmp = (sd_status[10] & 0xF0) >> 4;
2176 pCardStatus->AU_SIZE = (uint8_t)tmp;
2179 tmp = (sd_status[11] & 0xFF);
2180 pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
2183 tmp = (sd_status[12] & 0xFF);
2184 pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
2187 tmp = (sd_status[13] & 0xFC) >> 2;
2188 pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
2191 tmp = (sd_status[13] & 0x3);
2192 pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
2205 /* Private function ----------------------------------------------------------*/
2206 /** @addtogroup SD_Private_Functions
2211 * @brief SD DMA transfer complete Rx callback.
2212 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2213 * the configuration information for the specified DMA module.
2216 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
2218 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2220 /* DMA transfer is complete */
2221 hsd->DmaTransferCplt = 1;
2223 /* Wait until SD transfer is complete */
2224 while(hsd->SdTransferCplt == 0)
2228 /* Disable the DMA channel */
2229 HAL_DMA_Abort(hdma);
2231 /* Transfer complete user callback */
2232 HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
2236 * @brief SD DMA transfer Error Rx callback.
2237 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2238 * the configuration information for the specified DMA module.
2241 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
2243 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2245 /* Transfer complete user callback */
2246 HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
2250 * @brief SD DMA transfer complete Tx callback.
2251 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2252 * the configuration information for the specified DMA module.
2255 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
2257 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2259 /* DMA transfer is complete */
2260 hsd->DmaTransferCplt = 1;
2262 /* Wait until SD transfer is complete */
2263 while(hsd->SdTransferCplt == 0)
2267 /* Disable the DMA channel */
2268 HAL_DMA_Abort(hdma);
2270 /* Transfer complete user callback */
2271 HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
2275 * @brief SD DMA transfer Error Tx callback.
2276 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2277 * the configuration information for the specified DMA module.
2280 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
2282 SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
2284 /* Transfer complete user callback */
2285 HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
2289 * @brief Returns the SD current state.
2290 * @param hsd: SD handle
2291 * @retval SD card current state
2293 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
2297 if (SD_SendStatus(hsd, &resp1) != SD_OK)
2299 return SD_CARD_ERROR;
2303 return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
2308 * @brief Initializes all cards or single card as the case may be Card(s) come
2309 * into standby state.
2310 * @param hsd: SD handle
2311 * @retval SD Card error state
2313 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
2315 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2316 HAL_SD_ErrorTypedef errorstate = SD_OK;
2317 uint16_t sd_rca = 1;
2319 if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
2321 errorstate = SD_REQUEST_NOT_APPLICABLE;
2326 if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
2328 /* Send CMD2 ALL_SEND_CID */
2329 sdio_cmdinitstructure.Argument = 0;
2330 sdio_cmdinitstructure.CmdIndex = SD_CMD_ALL_SEND_CID;
2331 sdio_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
2332 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2333 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2334 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2336 /* Check for error conditions */
2337 errorstate = SD_CmdResp2Error(hsd);
2339 if(errorstate != SD_OK)
2344 /* Get Card identification number data */
2345 hsd->CID[0] = SDIO_GetResponse(SDIO_RESP1);
2346 hsd->CID[1] = SDIO_GetResponse(SDIO_RESP2);
2347 hsd->CID[2] = SDIO_GetResponse(SDIO_RESP3);
2348 hsd->CID[3] = SDIO_GetResponse(SDIO_RESP4);
2351 if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
2352 (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
2354 /* Send CMD3 SET_REL_ADDR with argument 0 */
2355 /* SD Card publishes its RCA. */
2356 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_REL_ADDR;
2357 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2358 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2360 /* Check for error conditions */
2361 errorstate = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
2363 if(errorstate != SD_OK)
2369 if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
2371 /* Get the SD card RCA */
2374 /* Send CMD9 SEND_CSD with argument as card's RCA */
2375 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
2376 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_CSD;
2377 sdio_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
2378 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2380 /* Check for error conditions */
2381 errorstate = SD_CmdResp2Error(hsd);
2383 if(errorstate != SD_OK)
2388 /* Get Card Specific Data */
2389 hsd->CSD[0] = SDIO_GetResponse(SDIO_RESP1);
2390 hsd->CSD[1] = SDIO_GetResponse(SDIO_RESP2);
2391 hsd->CSD[2] = SDIO_GetResponse(SDIO_RESP3);
2392 hsd->CSD[3] = SDIO_GetResponse(SDIO_RESP4);
2395 /* All cards are initialized */
2400 * @brief Selects of Deselects the corresponding card.
2401 * @param hsd: SD handle
2402 * @param addr: Address of the card to be selected
2403 * @retval SD Card error state
2405 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
2407 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2408 HAL_SD_ErrorTypedef errorstate = SD_OK;
2410 /* Send CMD7 SDIO_SEL_DESEL_CARD */
2411 sdio_cmdinitstructure.Argument = (uint32_t)addr;
2412 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEL_DESEL_CARD;
2413 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2414 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2415 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2416 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2418 /* Check for error conditions */
2419 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
2425 * @brief Enquires cards about their operating voltage and configures clock
2426 * controls and stores SD information that will be needed in future
2428 * @param hsd: SD handle
2429 * @retval SD Card error state
2431 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
2433 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2434 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
2435 uint32_t response = 0, count = 0, validvoltage = 0;
2436 uint32_t sdtype = SD_STD_CAPACITY;
2438 /* Power ON Sequence -------------------------------------------------------*/
2439 /* Disable SDIO Clock */
2440 __HAL_SD_SDIO_DISABLE();
2442 /* Set Power State to ON */
2443 SDIO_PowerState_ON(hsd->Instance);
2445 /* 1ms: required power up waiting time before starting the SD initialization
2449 /* Enable SDIO Clock */
2450 __HAL_SD_SDIO_ENABLE();
2452 /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
2453 /* No CMD response required */
2454 sdio_cmdinitstructure.Argument = 0;
2455 sdio_cmdinitstructure.CmdIndex = SD_CMD_GO_IDLE_STATE;
2456 sdio_cmdinitstructure.Response = SDIO_RESPONSE_NO;
2457 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2458 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2459 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2461 /* Check for error conditions */
2462 errorstate = SD_CmdError(hsd);
2464 if(errorstate != SD_OK)
2466 /* CMD Response Timeout (wait for CMDSENT flag) */
2470 /* CMD8: SEND_IF_COND ------------------------------------------------------*/
2471 /* Send CMD8 to verify SD card interface operating condition */
2472 /* Argument: - [31:12]: Reserved (shall be set to '0')
2473 - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
2474 - [7:0]: Check Pattern (recommended 0xAA) */
2475 /* CMD Response: R7 */
2476 sdio_cmdinitstructure.Argument = SD_CHECK_PATTERN;
2477 sdio_cmdinitstructure.CmdIndex = SD_SDIO_SEND_IF_COND;
2478 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2479 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2481 /* Check for error conditions */
2482 errorstate = SD_CmdResp7Error(hsd);
2484 if (errorstate == SD_OK)
2487 hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
2488 sdtype = SD_HIGH_CAPACITY;
2492 sdio_cmdinitstructure.Argument = 0;
2493 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
2494 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2496 /* Check for error conditions */
2497 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2499 /* If errorstate is Command Timeout, it is a MMC card */
2500 /* If errorstate is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
2502 if(errorstate == SD_OK)
2505 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2506 while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
2509 /* SEND CMD55 APP_CMD with RCA as 0 */
2510 sdio_cmdinitstructure.Argument = 0;
2511 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
2512 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2513 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2514 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2515 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2517 /* Check for error conditions */
2518 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2520 if(errorstate != SD_OK)
2526 sdio_cmdinitstructure.Argument = SD_VOLTAGE_WINDOW_SD | sdtype;
2527 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_OP_COND;
2528 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2529 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2530 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2531 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2533 /* Check for error conditions */
2534 errorstate = SD_CmdResp3Error(hsd);
2536 if(errorstate != SD_OK)
2541 /* Get command response */
2542 response = SDIO_GetResponse(SDIO_RESP1);
2544 /* Get operating voltage*/
2545 validvoltage = (((response >> 31) == 1) ? 1 : 0);
2550 if(count >= SD_MAX_VOLT_TRIAL)
2552 errorstate = SD_INVALID_VOLTRANGE;
2557 if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2559 hsd->CardType = HIGH_CAPACITY_SD_CARD;
2562 } /* else MMC Card */
2568 * @brief Turns the SDIO output signals off.
2569 * @param hsd: SD handle
2570 * @retval SD Card error state
2572 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
2574 HAL_SD_ErrorTypedef errorstate = SD_OK;
2576 /* Set Power State to OFF */
2577 SDIO_PowerState_OFF(hsd->Instance);
2583 * @brief Returns the current card's status.
2584 * @param hsd: SD handle
2585 * @param pCardStatus: pointer to the buffer that will contain the SD card
2586 * status (Card Status register)
2587 * @retval SD Card error state
2589 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
2591 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2592 HAL_SD_ErrorTypedef errorstate = SD_OK;
2594 if(pCardStatus == NULL)
2596 errorstate = SD_INVALID_PARAMETER;
2601 /* Send Status command */
2602 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
2603 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
2604 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2605 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2606 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2607 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2609 /* Check for error conditions */
2610 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
2612 if(errorstate != SD_OK)
2617 /* Get SD card status */
2618 *pCardStatus = SDIO_GetResponse(SDIO_RESP1);
2624 * @brief Checks for error conditions for CMD0.
2625 * @param hsd: SD handle
2626 * @retval SD Card error state
2628 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
2630 HAL_SD_ErrorTypedef errorstate = SD_OK;
2631 uint32_t timeout, tmp;
2633 timeout = SDIO_CMD0TIMEOUT;
2635 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2637 while((timeout > 0) && (!tmp))
2639 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2645 errorstate = SD_CMD_RSP_TIMEOUT;
2649 /* Clear all the static flags */
2650 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2656 * @brief Checks for error conditions for R7 response.
2657 * @param hsd: SD handle
2658 * @retval SD Card error state
2660 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
2662 HAL_SD_ErrorTypedef errorstate = SD_ERROR;
2663 uint32_t timeout = SDIO_CMD0TIMEOUT, tmp;
2665 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2667 while((!tmp) && (timeout > 0))
2669 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2673 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2675 if((timeout == 0) || tmp)
2677 /* Card is not V2.0 compliant or card does not support the set voltage range */
2678 errorstate = SD_CMD_RSP_TIMEOUT;
2680 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2685 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
2687 /* Card is SD V2.0 compliant */
2690 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
2699 * @brief Checks for error conditions for R1 response.
2700 * @param hsd: SD handle
2701 * @param SD_CMD: The sent command index
2702 * @retval SD Card error state
2704 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
2706 HAL_SD_ErrorTypedef errorstate = SD_OK;
2707 uint32_t response_r1;
2709 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2713 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2715 errorstate = SD_CMD_RSP_TIMEOUT;
2717 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2721 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2723 errorstate = SD_CMD_CRC_FAIL;
2725 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2730 /* Check response received is of desired command */
2731 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2733 errorstate = SD_ILLEGAL_CMD;
2738 /* Clear all the static flags */
2739 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2741 /* We have received response, retrieve it for analysis */
2742 response_r1 = SDIO_GetResponse(SDIO_RESP1);
2744 if((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
2749 if((response_r1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
2751 return(SD_ADDR_OUT_OF_RANGE);
2754 if((response_r1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
2756 return(SD_ADDR_MISALIGNED);
2759 if((response_r1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
2761 return(SD_BLOCK_LEN_ERR);
2764 if((response_r1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
2766 return(SD_ERASE_SEQ_ERR);
2769 if((response_r1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
2771 return(SD_BAD_ERASE_PARAM);
2774 if((response_r1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
2776 return(SD_WRITE_PROT_VIOLATION);
2779 if((response_r1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
2781 return(SD_LOCK_UNLOCK_FAILED);
2784 if((response_r1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
2786 return(SD_COM_CRC_FAILED);
2789 if((response_r1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
2791 return(SD_ILLEGAL_CMD);
2794 if((response_r1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
2796 return(SD_CARD_ECC_FAILED);
2799 if((response_r1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
2801 return(SD_CC_ERROR);
2804 if((response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
2806 return(SD_GENERAL_UNKNOWN_ERROR);
2809 if((response_r1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
2811 return(SD_STREAM_READ_UNDERRUN);
2814 if((response_r1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
2816 return(SD_STREAM_WRITE_OVERRUN);
2819 if((response_r1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
2821 return(SD_CID_CSD_OVERWRITE);
2824 if((response_r1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
2826 return(SD_WP_ERASE_SKIP);
2829 if((response_r1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
2831 return(SD_CARD_ECC_DISABLED);
2834 if((response_r1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
2836 return(SD_ERASE_RESET);
2839 if((response_r1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
2841 return(SD_AKE_SEQ_ERROR);
2848 * @brief Checks for error conditions for R3 (OCR) response.
2849 * @param hsd: SD handle
2850 * @retval SD Card error state
2852 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
2854 HAL_SD_ErrorTypedef errorstate = SD_OK;
2856 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2860 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2862 errorstate = SD_CMD_RSP_TIMEOUT;
2864 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2869 /* Clear all the static flags */
2870 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2876 * @brief Checks for error conditions for R2 (CID or CSD) response.
2877 * @param hsd: SD handle
2878 * @retval SD Card error state
2880 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
2882 HAL_SD_ErrorTypedef errorstate = SD_OK;
2884 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2888 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2890 errorstate = SD_CMD_RSP_TIMEOUT;
2892 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2896 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2898 errorstate = SD_CMD_CRC_FAIL;
2900 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2906 /* No error flag set */
2909 /* Clear all the static flags */
2910 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2916 * @brief Checks for error conditions for R6 (RCA) response.
2917 * @param hsd: SD handle
2918 * @param SD_CMD: The sent command index
2919 * @param pRCA: Pointer to the variable that will contain the SD card relative
2921 * @retval SD Card error state
2923 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
2925 HAL_SD_ErrorTypedef errorstate = SD_OK;
2926 uint32_t response_r1;
2928 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2932 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2934 errorstate = SD_CMD_RSP_TIMEOUT;
2936 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2940 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2942 errorstate = SD_CMD_CRC_FAIL;
2944 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2950 /* No error flag set */
2953 /* Check response received is of desired command */
2954 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2956 errorstate = SD_ILLEGAL_CMD;
2961 /* Clear all the static flags */
2962 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2964 /* We have received response, retrieve it. */
2965 response_r1 = SDIO_GetResponse(SDIO_RESP1);
2967 if((response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
2969 *pRCA = (uint16_t) (response_r1 >> 16);
2974 if((response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
2976 return(SD_GENERAL_UNKNOWN_ERROR);
2979 if((response_r1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
2981 return(SD_ILLEGAL_CMD);
2984 if((response_r1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
2986 return(SD_COM_CRC_FAILED);
2993 * @brief Enables the SDIO wide bus mode.
2994 * @param hsd: SD handle
2995 * @retval SD Card error state
2997 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
2999 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3000 HAL_SD_ErrorTypedef errorstate = SD_OK;
3002 uint32_t scr[2] = {0, 0};
3004 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
3006 errorstate = SD_LOCK_UNLOCK_FAILED;
3011 /* Get SCR Register */
3012 errorstate = SD_FindSCR(hsd, scr);
3014 if(errorstate != SD_OK)
3019 /* If requested card supports wide bus operation */
3020 if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
3022 /* Send CMD55 APP_CMD with argument as card's RCA.*/
3023 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3024 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3025 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3026 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3027 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3028 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3030 /* Check for error conditions */
3031 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3033 if(errorstate != SD_OK)
3038 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
3039 sdio_cmdinitstructure.Argument = 2;
3040 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
3041 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3043 /* Check for error conditions */
3044 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
3046 if(errorstate != SD_OK)
3055 errorstate = SD_REQUEST_NOT_APPLICABLE;
3062 * @brief Disables the SDIO wide bus mode.
3063 * @param hsd: SD handle
3064 * @retval SD Card error state
3066 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd)
3068 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3069 HAL_SD_ErrorTypedef errorstate = SD_OK;
3071 uint32_t scr[2] = {0, 0};
3073 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
3075 errorstate = SD_LOCK_UNLOCK_FAILED;
3080 /* Get SCR Register */
3081 errorstate = SD_FindSCR(hsd, scr);
3083 if(errorstate != SD_OK)
3088 /* If requested card supports 1 bit mode operation */
3089 if((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
3091 /* Send CMD55 APP_CMD with argument as card's RCA */
3092 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3093 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3094 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3095 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3096 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3097 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3099 /* Check for error conditions */
3100 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3102 if(errorstate != SD_OK)
3107 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
3108 sdio_cmdinitstructure.Argument = 0;
3109 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
3110 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3112 /* Check for error conditions */
3113 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
3115 if(errorstate != SD_OK)
3124 errorstate = SD_REQUEST_NOT_APPLICABLE;
3132 * @brief Finds the SD card SCR register value.
3133 * @param hsd: SD handle
3134 * @param pSCR: pointer to the buffer that will contain the SCR value
3135 * @retval SD Card error state
3137 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
3139 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3140 SDIO_DataInitTypeDef sdio_datainitstructure;
3141 HAL_SD_ErrorTypedef errorstate = SD_OK;
3143 uint32_t tempscr[2] = {0, 0};
3145 /* Set Block Size To 8 Bytes */
3146 /* Send CMD55 APP_CMD with argument as card's RCA */
3147 sdio_cmdinitstructure.Argument = (uint32_t)8;
3148 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
3149 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3150 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3151 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3152 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3154 /* Check for error conditions */
3155 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
3157 if(errorstate != SD_OK)
3162 /* Send CMD55 APP_CMD with argument as card's RCA */
3163 sdio_cmdinitstructure.Argument = (uint32_t)((hsd->RCA) << 16);
3164 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3165 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3167 /* Check for error conditions */
3168 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3170 if(errorstate != SD_OK)
3174 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
3175 sdio_datainitstructure.DataLength = 8;
3176 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
3177 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
3178 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
3179 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
3180 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
3182 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
3183 sdio_cmdinitstructure.Argument = 0;
3184 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_SEND_SCR;
3185 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3187 /* Check for error conditions */
3188 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_SEND_SCR);
3190 if(errorstate != SD_OK)
3195 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
3197 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
3199 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
3204 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
3206 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
3208 errorstate = SD_DATA_TIMEOUT;
3212 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
3214 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
3216 errorstate = SD_DATA_CRC_FAIL;
3220 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
3222 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
3224 errorstate = SD_RX_OVERRUN;
3228 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
3230 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
3232 errorstate = SD_START_BIT_ERR;
3238 /* No error flag set */
3241 /* Clear all the static flags */
3242 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
3244 *(pSCR + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) |\
3245 ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
3247 *(pSCR) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) |\
3248 ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
3254 * @brief Checks if the SD card is in programming state.
3255 * @param hsd: SD handle
3256 * @param pStatus: pointer to the variable that will contain the SD card state
3257 * @retval SD Card error state
3259 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus)
3261 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3262 HAL_SD_ErrorTypedef errorstate = SD_OK;
3263 __IO uint32_t responseR1 = 0;
3265 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3266 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
3267 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3268 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3269 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3270 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3272 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
3276 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
3278 errorstate = SD_CMD_RSP_TIMEOUT;
3280 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
3284 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
3286 errorstate = SD_CMD_CRC_FAIL;
3288 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
3294 /* No error flag set */
3297 /* Check response received is of desired command */
3298 if((uint32_t)SDIO_GetCommandResponse(hsd->Instance) != SD_CMD_SEND_STATUS)
3300 errorstate = SD_ILLEGAL_CMD;
3305 /* Clear all the static flags */
3306 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
3309 /* We have received response, retrieve it for analysis */
3310 responseR1 = SDIO_GetResponse(SDIO_RESP1);
3312 /* Find out card status */
3313 *pStatus = (uint8_t)((responseR1 >> 9) & 0x0000000F);
3315 if((responseR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
3320 if((responseR1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
3322 return(SD_ADDR_OUT_OF_RANGE);
3325 if((responseR1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
3327 return(SD_ADDR_MISALIGNED);
3330 if((responseR1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
3332 return(SD_BLOCK_LEN_ERR);
3335 if((responseR1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
3337 return(SD_ERASE_SEQ_ERR);
3340 if((responseR1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
3342 return(SD_BAD_ERASE_PARAM);
3345 if((responseR1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
3347 return(SD_WRITE_PROT_VIOLATION);
3350 if((responseR1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
3352 return(SD_LOCK_UNLOCK_FAILED);
3355 if((responseR1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
3357 return(SD_COM_CRC_FAILED);
3360 if((responseR1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
3362 return(SD_ILLEGAL_CMD);
3365 if((responseR1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
3367 return(SD_CARD_ECC_FAILED);
3370 if((responseR1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
3372 return(SD_CC_ERROR);
3375 if((responseR1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
3377 return(SD_GENERAL_UNKNOWN_ERROR);
3380 if((responseR1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
3382 return(SD_STREAM_READ_UNDERRUN);
3385 if((responseR1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
3387 return(SD_STREAM_WRITE_OVERRUN);
3390 if((responseR1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
3392 return(SD_CID_CSD_OVERWRITE);
3395 if((responseR1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
3397 return(SD_WP_ERASE_SKIP);
3400 if((responseR1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
3402 return(SD_CARD_ECC_DISABLED);
3405 if((responseR1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
3407 return(SD_ERASE_RESET);
3410 if((responseR1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
3412 return(SD_AKE_SEQ_ERROR);
3422 #endif /* HAL_SD_MODULE_ENABLED */
3432 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/