2 ******************************************************************************
3 * @file stm32f4xx_hal_sd.c
4 * @author MCD Application Team
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 __SDIO_CLK_ENABLE();
34 (##) SDIO pins configuration for SD card
35 (+++) Enable the clock for the SDIO GPIOs using the functions __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 __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-byte 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-byte block length (the block size should be
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-byte block length (the block size should be
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-byte 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) 2014 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 "stm32f4xx_hal.h"
182 /** @addtogroup STM32F4xx_HAL_Driver
187 * @brief SD HAL module driver
191 #ifdef HAL_SD_MODULE_ENABLED
193 /* Private typedef -----------------------------------------------------------*/
194 /* Private define ------------------------------------------------------------*/
195 /** @defgroup SD_Private_Define
200 * @brief SDIO Static flags, TimeOut, FIFO Address
202 #define SDIO_STATIC_FLAGS ((uint32_t)(SDIO_FLAG_CCRCFAIL | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_CTIMEOUT |\
203 SDIO_FLAG_DTIMEOUT | SDIO_FLAG_TXUNDERR | SDIO_FLAG_RXOVERR |\
204 SDIO_FLAG_CMDREND | SDIO_FLAG_CMDSENT | SDIO_FLAG_DATAEND |\
207 #define SDIO_CMD0TIMEOUT ((uint32_t)0x00010000)
210 * @brief Mask for errors Card Status R1 (OCR Register)
212 #define SD_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000)
213 #define SD_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000)
214 #define SD_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000)
215 #define SD_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000)
216 #define SD_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000)
217 #define SD_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000)
218 #define SD_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000)
219 #define SD_OCR_COM_CRC_FAILED ((uint32_t)0x00800000)
220 #define SD_OCR_ILLEGAL_CMD ((uint32_t)0x00400000)
221 #define SD_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000)
222 #define SD_OCR_CC_ERROR ((uint32_t)0x00100000)
223 #define SD_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000)
224 #define SD_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000)
225 #define SD_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000)
226 #define SD_OCR_CID_CSD_OVERWRIETE ((uint32_t)0x00010000)
227 #define SD_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000)
228 #define SD_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000)
229 #define SD_OCR_ERASE_RESET ((uint32_t)0x00002000)
230 #define SD_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008)
231 #define SD_OCR_ERRORBITS ((uint32_t)0xFDFFE008)
234 * @brief Masks for R6 Response
236 #define SD_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000)
237 #define SD_R6_ILLEGAL_CMD ((uint32_t)0x00004000)
238 #define SD_R6_COM_CRC_FAILED ((uint32_t)0x00008000)
240 #define SD_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000)
241 #define SD_HIGH_CAPACITY ((uint32_t)0x40000000)
242 #define SD_STD_CAPACITY ((uint32_t)0x00000000)
243 #define SD_CHECK_PATTERN ((uint32_t)0x000001AA)
245 #define SD_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFF)
246 #define SD_ALLZERO ((uint32_t)0x00000000)
248 #define SD_WIDE_BUS_SUPPORT ((uint32_t)0x00040000)
249 #define SD_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000)
250 #define SD_CARD_LOCKED ((uint32_t)0x02000000)
252 #define SD_DATATIMEOUT ((uint32_t)0xFFFFFFFF)
253 #define SD_0TO7BITS ((uint32_t)0x000000FF)
254 #define SD_8TO15BITS ((uint32_t)0x0000FF00)
255 #define SD_16TO23BITS ((uint32_t)0x00FF0000)
256 #define SD_24TO31BITS ((uint32_t)0xFF000000)
257 #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFF)
259 #define SD_HALFFIFO ((uint32_t)0x00000008)
260 #define SD_HALFFIFOBYTES ((uint32_t)0x00000020)
263 * @brief Command Class Supported
265 #define SD_CCCC_LOCK_UNLOCK ((uint32_t)0x00000080)
266 #define SD_CCCC_WRITE_PROT ((uint32_t)0x00000040)
267 #define SD_CCCC_ERASE ((uint32_t)0x00000020)
270 * @brief Following commands are SD Card Specific commands.
271 * SDIO_APP_CMD should be sent before sending these commands.
273 #define SD_SDIO_SEND_IF_COND ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
278 /* Private macro -------------------------------------------------------------*/
279 /* Private variables ---------------------------------------------------------*/
280 /* Private function prototypes -----------------------------------------------*/
281 /* Private functions ---------------------------------------------------------*/
282 /** @defgroup SD_Private_Functions SD Private Functions
285 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
286 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
287 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd);
288 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
289 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
290 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
291 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
292 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
293 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
294 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
295 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
296 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
297 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
298 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
299 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
300 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
301 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
302 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
303 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
304 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
309 /** @defgroup SD_Private_Functions
313 /** @defgroup SD_Group1 Initialization and de-initialization functions
314 * @brief Initialization and Configuration functions
317 ==============================================================================
318 ##### Initialization and de-initialization functions #####
319 ==============================================================================
321 This section provides functions allowing to initialize/de-initialize the SD
322 card device to be ready for use.
330 * @brief Initializes the SD card according to the specified parameters in the
331 SD_HandleTypeDef and create the associated handle.
332 * @param hsd: SD handle
333 * @param SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information
334 * @retval HAL SD error state
336 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
338 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
339 SD_InitTypeDef tmpinit;
341 /* Initialize the low level hardware (MSP) */
344 /* Default SDIO peripheral configuration for SD card initialization */
345 tmpinit.ClockEdge = SDIO_CLOCK_EDGE_RISING;
346 tmpinit.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
347 tmpinit.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
348 tmpinit.BusWide = SDIO_BUS_WIDE_1B;
349 tmpinit.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
350 tmpinit.ClockDiv = SDIO_INIT_CLK_DIV;
352 /* Initialize SDIO peripheral interface with default configuration */
353 SDIO_Init(hsd->Instance, tmpinit);
355 /* Identify card operating voltage */
356 errorstate = SD_PowerON(hsd);
358 if(errorstate != SD_OK)
363 /* Initialize the present SDIO card(s) and put them in idle state */
364 errorstate = SD_Initialize_Cards(hsd);
366 if (errorstate != SD_OK)
371 /* Read CSD/CID MSD registers */
372 errorstate = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
374 if (errorstate == SD_OK)
376 /* Select the Card */
377 errorstate = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
380 /* Configure SDIO peripheral interface */
381 SDIO_Init(hsd->Instance, hsd->Init);
387 * @brief De-Initializes the SD card.
388 * @param hsd: SD handle
391 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
394 /* Set SD power state to off */
397 /* De-Initialize the MSP layer */
398 HAL_SD_MspDeInit(hsd);
405 * @brief Initializes the SD MSP.
406 * @param hsd: SD handle
409 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
411 /* NOTE : This function Should not be modified, when the callback is needed,
412 the HAL_SD_MspInit could be implemented in the user file
417 * @brief De-Initialize SD MSP.
418 * @param hsd: SD handle
421 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
423 /* NOTE : This function Should not be modified, when the callback is needed,
424 the HAL_SD_MspDeInit could be implemented in the user file
432 /** @defgroup SD_Group2 IO operation functions
433 * @brief Data transfer functions
436 ==============================================================================
437 ##### IO operation functions #####
438 ==============================================================================
440 This subsection provides a set of functions allowing to manage the data
441 transfer from/to SD card.
448 * @brief Reads block(s) from a specified address in a card. The Data transfer
449 * is managed by polling mode.
450 * @param hsd: SD handle
451 * @param pReadBuffer: pointer to the buffer that will contain the received data
452 * @param ReadAddr: Address from where data is to be read
453 * @param BlockSize: SD card Data block size
454 * This parameter should be 512
455 * @param NumberOfBlocks: Number of SD blocks to read
456 * @retval SD Card error state
458 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
460 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
461 SDIO_DataInitTypeDef sdio_datainitstructure;
462 HAL_SD_ErrorTypedef errorstate = SD_OK;
463 uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
465 /* Initialize data control register */
466 hsd->Instance->DCTRL = 0;
468 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
474 /* Set Block Size for Card */
475 sdio_cmdinitstructure.Argument = (uint32_t) BlockSize;
476 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
477 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
478 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
479 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
480 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
482 /* Check for error conditions */
483 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
485 if (errorstate != SD_OK)
490 /* Configure the SD DPSM (Data Path State Machine) */
491 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
492 sdio_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
493 sdio_datainitstructure.DataBlockSize = (uint32_t)(9 << 4);
494 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
495 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
496 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
497 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
499 if(NumberOfBlocks > 1)
501 /* Send CMD18 READ_MULT_BLOCK with argument data address */
502 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
506 /* Send CMD17 READ_SINGLE_BLOCK */
507 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
510 sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
511 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
513 /* Read block(s) in polling mode */
514 if(NumberOfBlocks > 1)
516 /* Check for error conditions */
517 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
519 if (errorstate != SD_OK)
524 /* Poll on SDIO flags */
525 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
527 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
529 /* Read data from SDIO Rx FIFO */
530 for (count = 0; count < 8; count++)
532 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
541 /* Check for error conditions */
542 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
544 if (errorstate != SD_OK)
549 /* In case of single block transfer, no need of stop transfer at all */
550 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
552 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
554 /* Read data from SDIO Rx FIFO */
555 for (count = 0; count < 8; count++)
557 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
565 /* Send stop transmission command in case of multiblock read */
566 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
568 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
569 (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
570 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
572 /* Send stop transmission command */
573 errorstate = HAL_SD_StopTransfer(hsd);
577 /* Get error state */
578 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
580 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
582 errorstate = SD_DATA_TIMEOUT;
586 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
588 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
590 errorstate = SD_DATA_CRC_FAIL;
594 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
596 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
598 errorstate = SD_RX_OVERRUN;
602 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
604 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
606 errorstate = SD_START_BIT_ERR;
612 /* No error flag set */
615 count = SD_DATATIMEOUT;
617 /* Empty FIFO if there is still any data */
618 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
620 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
625 /* Clear all the static flags */
626 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
632 * @brief Allows to write block(s) to a specified address in a card. The Data
633 * transfer is managed by polling mode.
634 * @param hsd: SD handle
635 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
636 * @param WriteAddr: Address from where data is to be written
637 * @param BlockSize: SD card Data block size
638 * This parameter should be 512.
639 * @param NumberOfBlocks: Number of SD blocks to write
640 * @retval SD Card error state
642 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
644 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
645 SDIO_DataInitTypeDef sdio_datainitstructure;
646 HAL_SD_ErrorTypedef errorstate = SD_OK;
647 uint32_t totalnumberofbytes = 0, bytestransferred = 0, count = 0, restwords = 0;
648 uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
649 uint8_t cardstate = 0;
651 /* Initialize data control register */
652 hsd->Instance->DCTRL = 0;
654 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
660 /* Set Block Size for Card */
661 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
662 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
663 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
664 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
665 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
666 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
668 /* Check for error conditions */
669 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
671 if (errorstate != SD_OK)
676 if(NumberOfBlocks > 1)
678 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
679 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
683 /* Send CMD24 WRITE_SINGLE_BLOCK */
684 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
687 sdio_cmdinitstructure.Argument = (uint32_t)WriteAddr;
688 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
690 /* Check for error conditions */
691 if(NumberOfBlocks > 1)
693 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
697 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
700 if (errorstate != SD_OK)
705 /* Set total number of bytes to write */
706 totalnumberofbytes = NumberOfBlocks * BlockSize;
708 /* Configure the SD DPSM (Data Path State Machine) */
709 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
710 sdio_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
711 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
712 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
713 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
714 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
715 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
717 /* Write block(s) in polling mode */
718 if(NumberOfBlocks > 1)
720 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
722 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
724 if ((totalnumberofbytes - bytestransferred) < 32)
726 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
728 /* Write data to SDIO Tx FIFO */
729 for (count = 0; count < restwords; count++)
731 SDIO_WriteFIFO(hsd->Instance, tempbuff);
733 bytestransferred += 4;
738 /* Write data to SDIO Tx FIFO */
739 for (count = 0; count < 8; count++)
741 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
745 bytestransferred += 32;
752 /* In case of single data block transfer no need of stop command at all */
753 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
755 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
757 if ((totalnumberofbytes - bytestransferred) < 32)
759 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
761 /* Write data to SDIO Tx FIFO */
762 for (count = 0; count < restwords; count++)
764 SDIO_WriteFIFO(hsd->Instance, tempbuff);
766 bytestransferred += 4;
771 /* Write data to SDIO Tx FIFO */
772 for (count = 0; count < 8; count++)
774 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
778 bytestransferred += 32;
784 /* Send stop transmission command in case of multiblock write */
785 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
787 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
788 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
790 /* Send stop transmission command */
791 errorstate = HAL_SD_StopTransfer(hsd);
795 /* Get error state */
796 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
798 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
800 errorstate = SD_DATA_TIMEOUT;
804 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
806 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
808 errorstate = SD_DATA_CRC_FAIL;
812 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
814 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
816 errorstate = SD_TX_UNDERRUN;
820 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
822 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
824 errorstate = SD_START_BIT_ERR;
830 /* No error flag set */
833 /* Clear all the static flags */
834 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
836 /* Wait till the card is in programming state */
837 errorstate = SD_IsCardProgramming(hsd, &cardstate);
839 while ((errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
841 errorstate = SD_IsCardProgramming(hsd, &cardstate);
848 * @brief Reads block(s) from a specified address in a card. The Data transfer
849 * is managed by DMA mode.
850 * @note This API should be followed by the function HAL_SD_CheckReadOperation()
851 * to check the completion of the read process
852 * @param hsd: SD handle
853 * @param pReadBuffer: Pointer to the buffer that will contain the received data
854 * @param ReadAddr: Address from where data is to be read
855 * @param BlockSize: SD card Data block size
856 * This paramater should be 512.
857 * @param NumberOfBlocks: Number of blocks to read.
858 * @retval SD Card error state
860 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
862 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
863 SDIO_DataInitTypeDef sdio_datainitstructure;
864 HAL_SD_ErrorTypedef errorstate = SD_OK;
866 /* Initialize data control register */
867 hsd->Instance->DCTRL = 0;
869 /* Initialize handle flags */
870 hsd->SdTransferCplt = 0;
871 hsd->DmaTransferCplt = 0;
872 hsd->SdTransferErr = SD_OK;
874 /* Initialize SD Read operation */
875 if(NumberOfBlocks > 1)
877 hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
881 hsd->SdOperation = SD_READ_SINGLE_BLOCK;
884 /* Enable transfer interrupts */
885 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
891 /* Enable SDIO DMA transfer */
892 __HAL_SD_SDIO_DMA_ENABLE();
894 /* Configure DMA user callbacks */
895 hsd->hdmarx->XferCpltCallback = SD_DMA_RxCplt;
896 hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
898 /* Enable the DMA Stream */
899 HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks));
901 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
907 /* Set Block Size for Card */
908 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
909 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
910 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
911 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
912 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
913 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
915 /* Check for error conditions */
916 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
918 if (errorstate != SD_OK)
923 /* Configure the SD DPSM (Data Path State Machine) */
924 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
925 sdio_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
926 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
927 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
928 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
929 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
930 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
932 /* Check number of blocks command */
933 if(NumberOfBlocks > 1)
935 /* Send CMD18 READ_MULT_BLOCK with argument data address */
936 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
940 /* Send CMD17 READ_SINGLE_BLOCK */
941 sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
944 sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
945 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
947 /* Check for error conditions */
948 if(NumberOfBlocks > 1)
950 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
954 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
957 /* Update the SD transfer error in SD handle */
958 hsd->SdTransferErr = errorstate;
965 * @brief Writes block(s) to a specified address in a card. The Data transfer
966 * is managed by DMA mode.
967 * @note This API should be followed by the function HAL_SD_CheckWriteOperation()
968 * to check the completion of the write process (by SD current status polling).
969 * @param hsd: SD handle
970 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
971 * @param WriteAddr: Address from where data is to be read
972 * @param BlockSize: the SD card Data block size
973 * This parameter should be 512.
974 * @param NumberOfBlocks: Number of blocks to write
975 * @retval SD Card error state
977 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
979 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
980 SDIO_DataInitTypeDef sdio_datainitstructure;
981 HAL_SD_ErrorTypedef errorstate = SD_OK;
983 /* Initialize data control register */
984 hsd->Instance->DCTRL = 0;
986 /* Initialize handle flags */
987 hsd->SdTransferCplt = 0;
988 hsd->DmaTransferCplt = 0;
989 hsd->SdTransferErr = SD_OK;
991 /* Initialize SD Write operation */
992 if(NumberOfBlocks > 1)
994 hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
998 hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
1001 /* Enable transfer interrupts */
1002 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
1008 /* Configure DMA user callbacks */
1009 hsd->hdmatx->XferCpltCallback = SD_DMA_TxCplt;
1010 hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
1012 /* Enable the DMA Stream */
1013 HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BlockSize * NumberOfBlocks));
1015 /* Enable SDIO DMA transfer */
1016 __HAL_SD_SDIO_DMA_ENABLE();
1018 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1024 /* Set Block Size for Card */
1025 sdio_cmdinitstructure.Argument = (uint32_t)BlockSize;
1026 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1027 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1028 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1029 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1030 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1032 /* Check for error conditions */
1033 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1035 if (errorstate != SD_OK)
1040 /* Check number of blocks command */
1041 if(NumberOfBlocks <= 1)
1043 /* Send CMD24 WRITE_SINGLE_BLOCK */
1044 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
1048 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
1049 sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
1052 sdio_cmdinitstructure.Argument = (uint32_t)WriteAddr;
1053 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1055 /* Check for error conditions */
1056 if(NumberOfBlocks > 1)
1058 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
1062 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
1065 if (errorstate != SD_OK)
1070 /* Configure the SD DPSM (Data Path State Machine) */
1071 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
1072 sdio_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
1073 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1074 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1075 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1076 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
1077 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1079 hsd->SdTransferErr = errorstate;
1085 * @brief This function waits until the SD DMA data read transfer is finished.
1086 * This API should be called after HAL_SD_ReadBlocks_DMA() function
1087 * to insure that all data sent by the card is already transferred by the
1089 * @param hsd: SD handle
1090 * @param Timeout: Timeout duration
1091 * @retval SD Card error state
1093 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1095 HAL_SD_ErrorTypedef errorstate = SD_OK;
1096 uint32_t timeout = Timeout;
1097 uint32_t tmp1, tmp2;
1098 HAL_SD_ErrorTypedef tmp3;
1100 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1101 tmp1 = hsd->DmaTransferCplt;
1102 tmp2 = hsd->SdTransferCplt;
1103 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1105 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1107 tmp1 = hsd->DmaTransferCplt;
1108 tmp2 = hsd->SdTransferCplt;
1109 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1115 /* Wait until the Rx transfer is no longer active */
1116 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXACT)) && (timeout > 0))
1121 /* Send stop command in multiblock read */
1122 if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
1124 errorstate = HAL_SD_StopTransfer(hsd);
1127 if ((timeout == 0) && (errorstate == SD_OK))
1129 errorstate = SD_DATA_TIMEOUT;
1132 /* Clear all the static flags */
1133 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1135 /* Return error state */
1136 if (hsd->SdTransferErr != SD_OK)
1138 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1145 * @brief This function waits until the SD DMA data write transfer is finished.
1146 * This API should be called after HAL_SD_WriteBlocks_DMA() function
1147 * to insure that all data sent by the card is already transferred by the
1149 * @param hsd: SD handle
1150 * @param Timeout: Timeout duration
1151 * @retval SD Card error state
1153 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1155 HAL_SD_ErrorTypedef errorstate = SD_OK;
1156 uint32_t timeout = Timeout;
1157 uint32_t tmp1, tmp2;
1158 HAL_SD_ErrorTypedef tmp3;
1160 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1161 tmp1 = hsd->DmaTransferCplt;
1162 tmp2 = hsd->SdTransferCplt;
1163 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1165 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1167 tmp1 = hsd->DmaTransferCplt;
1168 tmp2 = hsd->SdTransferCplt;
1169 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1175 /* Wait until the Tx transfer is no longer active */
1176 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXACT)) && (timeout > 0))
1181 /* Send stop command in multiblock write */
1182 if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
1184 errorstate = HAL_SD_StopTransfer(hsd);
1187 if ((timeout == 0) && (errorstate == SD_OK))
1189 errorstate = SD_DATA_TIMEOUT;
1192 /* Clear all the static flags */
1193 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1195 /* Return error state */
1196 if (hsd->SdTransferErr != SD_OK)
1198 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1201 /* Wait until write is complete */
1202 while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
1210 * @brief Erases the specified memory area of the given SD card.
1211 * @param hsd: SD handle
1212 * @param startaddr: Start byte address
1213 * @param endaddr: End byte address
1214 * @retval SD Card error state
1216 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
1218 HAL_SD_ErrorTypedef errorstate = SD_OK;
1219 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1222 __IO uint32_t maxdelay = 0;
1223 uint8_t cardstate = 0;
1225 /* Check if the card command class supports erase command */
1226 if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
1228 errorstate = SD_REQUEST_NOT_APPLICABLE;
1233 /* Get max delay value */
1234 maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
1236 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1238 errorstate = SD_LOCK_UNLOCK_FAILED;
1243 /* Get start and end block for high capacity cards */
1244 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1250 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1251 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1252 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1254 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
1255 sdio_cmdinitstructure.Argument =(uint32_t)startaddr;
1256 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_START;
1257 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1258 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1259 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1260 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1262 /* Check for error conditions */
1263 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
1265 if (errorstate != SD_OK)
1270 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
1271 sdio_cmdinitstructure.Argument = (uint32_t)endaddr;
1272 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_END;
1273 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1275 /* Check for error conditions */
1276 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
1278 if (errorstate != SD_OK)
1284 /* Send CMD38 ERASE */
1285 sdio_cmdinitstructure.Argument = 0;
1286 sdio_cmdinitstructure.CmdIndex = SD_CMD_ERASE;
1287 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1289 /* Check for error conditions */
1290 errorstate = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
1292 if (errorstate != SD_OK)
1297 for (; delay < maxdelay; delay++)
1301 /* Wait untill the card is in programming state */
1302 errorstate = SD_IsCardProgramming(hsd, &cardstate);
1304 delay = SD_DATATIMEOUT;
1306 while ((delay > 0) && (errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
1308 errorstate = SD_IsCardProgramming(hsd, &cardstate);
1316 * @brief This function handles SD card interrupt request.
1317 * @param hsd: SD handle
1320 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1322 /* Check for SDIO interrupt flags */
1323 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DATAEND))
1325 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_IT_DATAEND);
1327 /* SD transfer is complete */
1328 hsd->SdTransferCplt = 1;
1330 /* No transfer error */
1331 hsd->SdTransferErr = SD_OK;
1333 HAL_SD_XferCpltCallback(hsd);
1335 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DCRCFAIL))
1337 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1339 hsd->SdTransferErr = SD_DATA_CRC_FAIL;
1341 HAL_SD_XferErrorCallback(hsd);
1344 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DTIMEOUT))
1346 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1348 hsd->SdTransferErr = SD_DATA_TIMEOUT;
1350 HAL_SD_XferErrorCallback(hsd);
1352 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_RXOVERR))
1354 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1356 hsd->SdTransferErr = SD_RX_OVERRUN;
1358 HAL_SD_XferErrorCallback(hsd);
1360 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_TXUNDERR))
1362 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
1364 hsd->SdTransferErr = SD_TX_UNDERRUN;
1366 HAL_SD_XferErrorCallback(hsd);
1368 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_STBITERR))
1370 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1372 hsd->SdTransferErr = SD_START_BIT_ERR;
1374 HAL_SD_XferErrorCallback(hsd);
1378 /* No error flag set */
1381 /* Disable all SDIO peripheral interrupt sources */
1382 __HAL_SD_SDIO_DISABLE_IT(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |\
1383 SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |\
1384 SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1389 * @brief SD end of transfer callback.
1390 * @param hsd: SD handle
1393 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
1395 /* NOTE : This function Should not be modified, when the callback is needed,
1396 the HAL_SD_XferCpltCallback could be implemented in the user file
1401 * @brief SD Transfer Error callback.
1402 * @param hsd: SD handle
1405 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
1407 /* NOTE : This function Should not be modified, when the callback is needed,
1408 the HAL_SD_XferErrorCallback could be implemented in the user file
1413 * @brief SD Transfer complete Rx callback in non blocking mode.
1414 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1415 * the configuration information for the specified DMA module.
1418 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
1420 /* NOTE : This function Should not be modified, when the callback is needed,
1421 the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
1426 * @brief SD DMA transfer complete Rx error callback.
1427 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1428 * the configuration information for the specified DMA module.
1431 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
1433 /* NOTE : This function Should not be modified, when the callback is needed,
1434 the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
1439 * @brief SD Transfer complete Tx callback in non blocking mode.
1440 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1441 * the configuration information for the specified DMA module.
1444 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
1446 /* NOTE : This function Should not be modified, when the callback is needed,
1447 the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
1452 * @brief SD DMA transfer complete error Tx callback.
1453 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1454 * the configuration information for the specified DMA module.
1457 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
1459 /* NOTE : This function Should not be modified, when the callback is needed,
1460 the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
1468 /** @defgroup SD_Group3 Peripheral Control functions
1469 * @brief management functions
1472 ==============================================================================
1473 ##### Peripheral Control functions #####
1474 ==============================================================================
1476 This subsection provides a set of functions allowing to control the SD card
1484 * @brief Returns information about specific card.
1485 * @param hsd: SD handle
1486 * @param pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
1487 * contains all SD cardinformation
1488 * @retval SD Card error state
1490 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
1492 HAL_SD_ErrorTypedef errorstate = SD_OK;
1495 pCardInfo->CardType = (uint8_t)(hsd->CardType);
1496 pCardInfo->RCA = (uint16_t)(hsd->RCA);
1499 tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
1500 pCardInfo->SD_csd.CSDStruct = (uint8_t)((tmp & 0xC0) >> 6);
1501 pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
1502 pCardInfo->SD_csd.Reserved1 = tmp & 0x03;
1505 tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
1506 pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
1509 tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
1510 pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
1513 tmp = hsd->CSD[0] & 0x000000FF;
1514 pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
1517 tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
1518 pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
1521 tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
1522 pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
1523 pCardInfo->SD_csd.RdBlockLen = (uint8_t)(tmp & 0x0F);
1526 tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
1527 pCardInfo->SD_csd.PartBlockRead = (uint8_t)((tmp & 0x80) >> 7);
1528 pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
1529 pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
1530 pCardInfo->SD_csd.DSRImpl = (uint8_t)((tmp & 0x10) >> 4);
1531 pCardInfo->SD_csd.Reserved2 = 0; /*!< Reserved */
1533 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
1535 pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
1538 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1539 pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
1542 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1543 pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
1545 pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
1546 pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
1549 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1550 pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
1551 pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
1552 pCardInfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
1554 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1555 pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
1557 pCardInfo->CardCapacity = (pCardInfo->SD_csd.DeviceSize + 1) ;
1558 pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
1559 pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
1560 pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
1562 else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1565 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1566 pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
1569 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1571 pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
1574 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1576 pCardInfo->SD_csd.DeviceSize |= (tmp);
1579 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1581 pCardInfo->CardCapacity = ((pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024;
1582 pCardInfo->CardBlockSize = 512;
1586 /* Not supported card type */
1587 errorstate = SD_ERROR;
1590 pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
1591 pCardInfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
1594 tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
1595 pCardInfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
1596 pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
1599 tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
1600 pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
1601 pCardInfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
1602 pCardInfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
1603 pCardInfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
1606 tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
1607 pCardInfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
1608 pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
1609 pCardInfo->SD_csd.Reserved3 = 0;
1610 pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
1613 tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
1614 pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
1615 pCardInfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
1616 pCardInfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
1617 pCardInfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
1618 pCardInfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
1619 pCardInfo->SD_csd.ECC = (tmp & 0x03);
1622 tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
1623 pCardInfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
1624 pCardInfo->SD_csd.Reserved4 = 1;
1627 tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
1628 pCardInfo->SD_cid.ManufacturerID = tmp;
1631 tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
1632 pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
1635 tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
1636 pCardInfo->SD_cid.OEM_AppliID |= tmp;
1639 tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
1640 pCardInfo->SD_cid.ProdName1 = tmp << 24;
1643 tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
1644 pCardInfo->SD_cid.ProdName1 |= tmp << 16;
1647 tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
1648 pCardInfo->SD_cid.ProdName1 |= tmp << 8;
1651 tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
1652 pCardInfo->SD_cid.ProdName1 |= tmp;
1655 tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
1656 pCardInfo->SD_cid.ProdName2 = tmp;
1659 tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
1660 pCardInfo->SD_cid.ProdRev = tmp;
1663 tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
1664 pCardInfo->SD_cid.ProdSN = tmp << 24;
1667 tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
1668 pCardInfo->SD_cid.ProdSN |= tmp << 16;
1671 tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
1672 pCardInfo->SD_cid.ProdSN |= tmp << 8;
1675 tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
1676 pCardInfo->SD_cid.ProdSN |= tmp;
1679 tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
1680 pCardInfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
1681 pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
1684 tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
1685 pCardInfo->SD_cid.ManufactDate |= tmp;
1688 tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
1689 pCardInfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
1690 pCardInfo->SD_cid.Reserved2 = 1;
1696 * @brief Enables wide bus operation for the requested card if supported by
1698 * @param hsd: SD handle
1699 * @param WideMode: Specifies the SD card wide bus mode
1700 * This parameter can be one of the following values:
1701 * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
1702 * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
1703 * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
1704 * @retval SD Card error state
1706 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
1708 HAL_SD_ErrorTypedef errorstate = SD_OK;
1709 SDIO_InitTypeDef tmpinit;
1711 /* MMC Card does not support this feature */
1712 if (hsd->CardType == MULTIMEDIA_CARD)
1714 errorstate = SD_UNSUPPORTED_FEATURE;
1718 else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1719 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1721 if (WideMode == SDIO_BUS_WIDE_8B)
1723 errorstate = SD_UNSUPPORTED_FEATURE;
1725 else if (WideMode == SDIO_BUS_WIDE_4B)
1727 errorstate = SD_WideBus_Enable(hsd);
1729 else if (WideMode == SDIO_BUS_WIDE_1B)
1731 errorstate = SD_WideBus_Disable(hsd);
1735 /* WideMode is not a valid argument*/
1736 errorstate = SD_INVALID_PARAMETER;
1739 if (errorstate == SD_OK)
1741 /* Configure the SDIO peripheral */
1742 tmpinit.ClockEdge = hsd->Init.ClockEdge;
1743 tmpinit.ClockBypass = hsd->Init.ClockBypass;
1744 tmpinit.ClockPowerSave = hsd->Init.ClockPowerSave;
1745 tmpinit.BusWide = WideMode;
1746 tmpinit.HardwareFlowControl = hsd->Init.HardwareFlowControl;
1747 tmpinit.ClockDiv = hsd->Init.ClockDiv;
1748 SDIO_Init(hsd->Instance, tmpinit);
1756 * @brief Aborts an ongoing data transfer.
1757 * @param hsd: SD handle
1758 * @retval SD Card error state
1760 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
1762 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1763 HAL_SD_ErrorTypedef errorstate = SD_OK;
1765 /* Send CMD12 STOP_TRANSMISSION */
1766 sdio_cmdinitstructure.Argument = 0;
1767 sdio_cmdinitstructure.CmdIndex = SD_CMD_STOP_TRANSMISSION;
1768 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1769 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1770 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1771 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1773 /* Check for error conditions */
1774 errorstate = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
1780 * @brief Switches the SD card to High Speed mode.
1781 * This API must be used after "Transfer State"
1782 * @note This operation should be followed by the configuration
1783 * of PLL to have SDIOCK clock between 67 and 75 MHz
1784 * @param hsd: SD handle
1785 * @retval SD Card error state
1787 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
1789 HAL_SD_ErrorTypedef errorstate = SD_OK;
1790 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1791 SDIO_DataInitTypeDef sdio_datainitstructure;
1793 uint8_t SD_hs[64] = {0};
1794 uint32_t SD_scr[2] = {0, 0};
1795 uint32_t SD_SPEC = 0 ;
1796 uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
1798 /* Initialize the Data control register */
1799 hsd->Instance->DCTRL = 0;
1801 /* Get SCR Register */
1802 errorstate = SD_FindSCR(hsd, SD_scr);
1804 if (errorstate != SD_OK)
1809 /* Test the Version supported by the card*/
1810 SD_SPEC = (SD_scr[1] & 0x01000000) | (SD_scr[1] & 0x02000000);
1812 if (SD_SPEC != SD_ALLZERO)
1814 /* Set Block Size for Card */
1815 sdio_cmdinitstructure.Argument = (uint32_t)64;
1816 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1817 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1818 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1819 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1820 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1822 /* Check for error conditions */
1823 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1825 if (errorstate != SD_OK)
1830 /* Configure the SD DPSM (Data Path State Machine) */
1831 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
1832 sdio_datainitstructure.DataLength = 64;
1833 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
1834 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1835 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1836 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
1837 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1839 /* Send CMD6 switch mode */
1840 sdio_cmdinitstructure.Argument = 0x80FFFF01;
1841 sdio_cmdinitstructure.CmdIndex = SD_CMD_HS_SWITCH;
1842 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1844 /* Check for error conditions */
1845 errorstate = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
1847 if (errorstate != SD_OK)
1852 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
1854 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
1856 for (count = 0; count < 8; count++)
1858 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
1865 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
1867 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1869 errorstate = SD_DATA_TIMEOUT;
1873 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
1875 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1877 errorstate = SD_DATA_CRC_FAIL;
1881 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
1883 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1885 errorstate = SD_RX_OVERRUN;
1889 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
1891 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1893 errorstate = SD_START_BIT_ERR;
1899 /* No error flag set */
1902 count = SD_DATATIMEOUT;
1904 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
1906 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
1911 /* Clear all the static flags */
1912 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1914 /* Test if the switch mode HS is ok */
1915 if ((SD_hs[13]& 2) != 2)
1917 errorstate = SD_UNSUPPORTED_FEATURE;
1928 /** @defgroup SD_Group4 Peripheral State functions
1929 * @brief Peripheral State functions
1932 ==============================================================================
1933 ##### Peripheral State functions #####
1934 ==============================================================================
1936 This subsection permits to get in runtime the status of the peripheral
1944 * @brief Returns the current SD card's status.
1945 * @param hsd: SD handle
1946 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
1947 * SD Status register)
1948 * @retval SD Card error state
1950 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
1952 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1953 SDIO_DataInitTypeDef sdio_datainitstructure;
1954 HAL_SD_ErrorTypedef errorstate = SD_OK;
1957 /* Check SD response */
1958 if ((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1960 errorstate = SD_LOCK_UNLOCK_FAILED;
1965 /* Set block size for card if it is not equal to current block size for card */
1966 sdio_cmdinitstructure.Argument = 64;
1967 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
1968 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
1969 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1970 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
1971 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1973 /* Check for error conditions */
1974 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1976 if (errorstate != SD_OK)
1982 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
1983 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
1984 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1986 /* Check for error conditions */
1987 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
1989 if (errorstate != SD_OK)
1994 /* Configure the SD DPSM (Data Path State Machine) */
1995 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
1996 sdio_datainitstructure.DataLength = 64;
1997 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
1998 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1999 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
2000 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
2001 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
2003 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
2004 sdio_cmdinitstructure.Argument = 0;
2005 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_STAUS;
2006 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2008 /* Check for error conditions */
2009 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STAUS);
2011 if (errorstate != SD_OK)
2016 /* Get status data */
2017 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
2019 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2021 for (count = 0; count < 8; count++)
2023 *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
2030 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
2032 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
2034 errorstate = SD_DATA_TIMEOUT;
2038 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2040 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
2042 errorstate = SD_DATA_CRC_FAIL;
2046 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2048 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
2050 errorstate = SD_RX_OVERRUN;
2054 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
2056 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
2058 errorstate = SD_START_BIT_ERR;
2064 /* No error flag set */
2067 count = SD_DATATIMEOUT;
2068 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
2070 *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
2075 /* Clear all the static status flags*/
2076 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2082 * @brief Gets the current sd card data status.
2083 * @param hsd: SD handle
2084 * @retval Data Transfer state
2086 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
2088 HAL_SD_CardStateTypedef cardstate = SD_CARD_TRANSFER;
2090 /* Get SD card state */
2091 cardstate = SD_GetState(hsd);
2093 /* Find SD status according to card state*/
2094 if (cardstate == SD_CARD_TRANSFER)
2096 return SD_TRANSFER_OK;
2098 else if(cardstate == SD_CARD_ERROR)
2100 return SD_TRANSFER_ERROR;
2104 return SD_TRANSFER_BUSY;
2109 * @brief Gets the SD card status.
2110 * @param hsd: SD handle
2111 * @param pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
2112 * will contain the SD card status information
2113 * @retval SD Card error state
2115 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
2117 HAL_SD_ErrorTypedef errorstate = SD_OK;
2119 uint32_t sd_status[16];
2121 errorstate = HAL_SD_SendSDStatus(hsd, sd_status);
2123 if (errorstate != SD_OK)
2129 tmp = (sd_status[0] & 0xC0) >> 6;
2130 pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
2133 tmp = (sd_status[0] & 0x20) >> 5;
2134 pCardStatus->SECURED_MODE = (uint8_t)tmp;
2137 tmp = (sd_status[2] & 0xFF);
2138 pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
2141 tmp = (sd_status[3] & 0xFF);
2142 pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
2145 tmp = (sd_status[4] & 0xFF);
2146 pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
2149 tmp = (sd_status[5] & 0xFF);
2150 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
2153 tmp = (sd_status[6] & 0xFF);
2154 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
2157 tmp = (sd_status[7] & 0xFF);
2158 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
2161 tmp = (sd_status[8] & 0xFF);
2162 pCardStatus->SPEED_CLASS = (uint8_t)tmp;
2165 tmp = (sd_status[9] & 0xFF);
2166 pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
2169 tmp = (sd_status[10] & 0xF0) >> 4;
2170 pCardStatus->AU_SIZE = (uint8_t)tmp;
2173 tmp = (sd_status[11] & 0xFF);
2174 pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
2177 tmp = (sd_status[12] & 0xFF);
2178 pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
2181 tmp = (sd_status[13] & 0xFC) >> 2;
2182 pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
2185 tmp = (sd_status[13] & 0x3);
2186 pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
2199 /** @addtogroup SD_Private_Functions
2204 * @brief SD DMA transfer complete Rx callback.
2205 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2206 * the configuration information for the specified DMA module.
2209 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
2211 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2213 /* DMA transfer is complete */
2214 hsd->DmaTransferCplt = 1;
2216 /* Wait until SD transfer is complete */
2217 while(hsd->SdTransferCplt == 0)
2221 /* Transfer complete user callback */
2222 HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
2226 * @brief SD DMA transfer Error Rx callback.
2227 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2228 * the configuration information for the specified DMA module.
2231 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
2233 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2235 /* Transfer complete user callback */
2236 HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
2240 * @brief SD DMA transfer complete Tx callback.
2241 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2242 * the configuration information for the specified DMA module.
2245 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
2247 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2249 /* DMA transfer is complete */
2250 hsd->DmaTransferCplt = 1;
2252 /* Wait until SD transfer is complete */
2253 while(hsd->SdTransferCplt == 0)
2257 /* Transfer complete user callback */
2258 HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
2262 * @brief SD DMA transfer Error Tx callback.
2263 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
2264 * the configuration information for the specified DMA module.
2267 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
2269 SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
2271 /* Transfer complete user callback */
2272 HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
2276 * @brief Returns the SD current state.
2277 * @param hsd: SD handle
2278 * @retval SD card current state
2280 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
2284 if (SD_SendStatus(hsd, &resp1) != SD_OK)
2286 return SD_CARD_ERROR;
2290 return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
2295 * @brief Initializes all cards or single card as the case may be Card(s) come
2296 * into standby state.
2297 * @param hsd: SD handle
2298 * @retval SD Card error state
2300 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
2302 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2303 HAL_SD_ErrorTypedef errorstate = SD_OK;
2304 uint16_t sd_rca = 1;
2306 if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
2308 errorstate = SD_REQUEST_NOT_APPLICABLE;
2313 if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
2315 /* Send CMD2 ALL_SEND_CID */
2316 sdio_cmdinitstructure.Argument = 0;
2317 sdio_cmdinitstructure.CmdIndex = SD_CMD_ALL_SEND_CID;
2318 sdio_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
2319 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2320 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2321 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2323 /* Check for error conditions */
2324 errorstate = SD_CmdResp2Error(hsd);
2326 if(errorstate != SD_OK)
2331 /* Get Card identification number data */
2332 hsd->CID[0] = SDIO_GetResponse(SDIO_RESP1);
2333 hsd->CID[1] = SDIO_GetResponse(SDIO_RESP2);
2334 hsd->CID[2] = SDIO_GetResponse(SDIO_RESP3);
2335 hsd->CID[3] = SDIO_GetResponse(SDIO_RESP4);
2338 if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
2339 (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
2341 /* Send CMD3 SET_REL_ADDR with argument 0 */
2342 /* SD Card publishes its RCA. */
2343 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_REL_ADDR;
2344 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2345 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2347 /* Check for error conditions */
2348 errorstate = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
2350 if(errorstate != SD_OK)
2356 if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
2358 /* Get the SD card RCA */
2361 /* Send CMD9 SEND_CSD with argument as card's RCA */
2362 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
2363 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_CSD;
2364 sdio_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
2365 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2367 /* Check for error conditions */
2368 errorstate = SD_CmdResp2Error(hsd);
2370 if(errorstate != SD_OK)
2375 /* Get Card Specific Data */
2376 hsd->CSD[0] = SDIO_GetResponse(SDIO_RESP1);
2377 hsd->CSD[1] = SDIO_GetResponse(SDIO_RESP2);
2378 hsd->CSD[2] = SDIO_GetResponse(SDIO_RESP3);
2379 hsd->CSD[3] = SDIO_GetResponse(SDIO_RESP4);
2382 /* All cards are initialized */
2387 * @brief Selects od Deselects the corresponding card.
2388 * @param hsd: SD handle
2389 * @param addr: Address of the card to be selected
2390 * @retval SD Card error state
2392 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
2394 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2395 HAL_SD_ErrorTypedef errorstate = SD_OK;
2397 /* Send CMD7 SDIO_SEL_DESEL_CARD */
2398 sdio_cmdinitstructure.Argument = (uint32_t)addr;
2399 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEL_DESEL_CARD;
2400 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2401 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2402 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2403 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2405 /* Check for error conditions */
2406 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
2412 * @brief Enquires cards about their operating voltage and configures clock
2413 * controls and stores SD information that will be needed in future
2415 * @param hsd: SD handle
2416 * @retval SD Card error state
2418 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
2420 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2421 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
2422 uint32_t response = 0, count = 0, validvoltage = 0;
2423 uint32_t sdtype = SD_STD_CAPACITY;
2425 /* Power ON Sequence -------------------------------------------------------*/
2426 /* Disable SDIO Clock */
2427 __HAL_SD_SDIO_DISABLE();
2429 /* Set Power State to ON */
2430 SDIO_PowerState_ON(hsd->Instance);
2432 /* Enable SDIO Clock */
2433 __HAL_SD_SDIO_ENABLE();
2435 /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
2436 /* No CMD response required */
2437 sdio_cmdinitstructure.Argument = 0;
2438 sdio_cmdinitstructure.CmdIndex = SD_CMD_GO_IDLE_STATE;
2439 sdio_cmdinitstructure.Response = SDIO_RESPONSE_NO;
2440 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2441 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2442 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2444 /* Check for error conditions */
2445 errorstate = SD_CmdError(hsd);
2447 if(errorstate != SD_OK)
2449 /* CMD Response TimeOut (wait for CMDSENT flag) */
2453 /* CMD8: SEND_IF_COND ------------------------------------------------------*/
2454 /* Send CMD8 to verify SD card interface operating condition */
2455 /* Argument: - [31:12]: Reserved (shall be set to '0')
2456 - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
2457 - [7:0]: Check Pattern (recommended 0xAA) */
2458 /* CMD Response: R7 */
2459 sdio_cmdinitstructure.Argument = SD_CHECK_PATTERN;
2460 sdio_cmdinitstructure.CmdIndex = SD_SDIO_SEND_IF_COND;
2461 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2462 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2464 /* Check for error conditions */
2465 errorstate = SD_CmdResp7Error(hsd);
2467 if (errorstate == SD_OK)
2470 hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
2471 sdtype = SD_HIGH_CAPACITY;
2475 sdio_cmdinitstructure.Argument = 0;
2476 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
2477 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2479 /* Check for error conditions */
2480 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2482 /* If errorstate is Command TimeOut, it is a MMC card */
2483 /* If errorstate is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
2485 if(errorstate == SD_OK)
2488 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2489 while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
2492 /* SEND CMD55 APP_CMD with RCA as 0 */
2493 sdio_cmdinitstructure.Argument = 0;
2494 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
2495 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2496 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2497 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2498 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2500 /* Check for error conditions */
2501 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2503 if(errorstate != SD_OK)
2509 sdio_cmdinitstructure.Argument = SD_VOLTAGE_WINDOW_SD | sdtype;
2510 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_OP_COND;
2511 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2512 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2513 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2514 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2516 /* Check for error conditions */
2517 errorstate = SD_CmdResp3Error(hsd);
2519 if(errorstate != SD_OK)
2524 /* Get command response */
2525 response = SDIO_GetResponse(SDIO_RESP1);
2527 /* Get operating voltage*/
2528 validvoltage = (((response >> 31) == 1) ? 1 : 0);
2533 if(count >= SD_MAX_VOLT_TRIAL)
2535 errorstate = SD_INVALID_VOLTRANGE;
2540 if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2542 hsd->CardType = HIGH_CAPACITY_SD_CARD;
2545 } /* else MMC Card */
2551 * @brief Turns the SDIO output signals off.
2552 * @param hsd: SD handle
2553 * @retval SD Card error state
2555 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
2557 HAL_SD_ErrorTypedef errorstate = SD_OK;
2559 /* Set Power State to OFF */
2560 SDIO_PowerState_OFF(hsd->Instance);
2566 * @brief Returns the current card's status.
2567 * @param hsd: SD handle
2568 * @param pCardStatus: pointer to the buffer that will contain the SD card
2569 * status (Card Status register)
2570 * @retval SD Card error state
2572 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
2574 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2575 HAL_SD_ErrorTypedef errorstate = SD_OK;
2577 if(pCardStatus == HAL_NULL)
2579 errorstate = SD_INVALID_PARAMETER;
2584 /* Send Status command */
2585 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
2586 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
2587 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
2588 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2589 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
2590 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2592 /* Check for error conditions */
2593 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
2595 if(errorstate != SD_OK)
2600 /* Get SD card status */
2601 *pCardStatus = SDIO_GetResponse(SDIO_RESP1);
2607 * @brief Checks for error conditions for CMD0.
2608 * @param hsd: SD handle
2609 * @retval SD Card error state
2611 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
2613 HAL_SD_ErrorTypedef errorstate = SD_OK;
2614 uint32_t timeout, tmp;
2616 timeout = SDIO_CMD0TIMEOUT;
2618 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2620 while((timeout > 0) && (!tmp))
2622 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2628 errorstate = SD_CMD_RSP_TIMEOUT;
2632 /* Clear all the static flags */
2633 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2639 * @brief Checks for error conditions for R7 response.
2640 * @param hsd: SD handle
2641 * @retval SD Card error state
2643 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
2645 HAL_SD_ErrorTypedef errorstate = SD_ERROR;
2646 uint32_t timeout = SDIO_CMD0TIMEOUT, tmp;
2648 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2650 while((!tmp) && (timeout > 0))
2652 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2656 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2658 if((timeout == 0) || tmp)
2660 /* Card is not V2.0 compliant or card does not support the set voltage range */
2661 errorstate = SD_CMD_RSP_TIMEOUT;
2663 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2668 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
2670 /* Card is SD V2.0 compliant */
2673 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
2682 * @brief Checks for error conditions for R1 response.
2683 * @param hsd: SD handle
2684 * @param SD_CMD: The sent command index
2685 * @retval SD Card error state
2687 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
2689 HAL_SD_ErrorTypedef errorstate = SD_OK;
2690 uint32_t response_r1;
2692 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2696 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2698 errorstate = SD_CMD_RSP_TIMEOUT;
2700 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2704 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2706 errorstate = SD_CMD_CRC_FAIL;
2708 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2713 /* Check response received is of desired command */
2714 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2716 errorstate = SD_ILLEGAL_CMD;
2721 /* Clear all the static flags */
2722 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2724 /* We have received response, retrieve it for analysis */
2725 response_r1 = SDIO_GetResponse(SDIO_RESP1);
2727 if((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
2732 if((response_r1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
2734 return(SD_ADDR_OUT_OF_RANGE);
2737 if((response_r1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
2739 return(SD_ADDR_MISALIGNED);
2742 if((response_r1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
2744 return(SD_BLOCK_LEN_ERR);
2747 if((response_r1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
2749 return(SD_ERASE_SEQ_ERR);
2752 if((response_r1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
2754 return(SD_BAD_ERASE_PARAM);
2757 if((response_r1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
2759 return(SD_WRITE_PROT_VIOLATION);
2762 if((response_r1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
2764 return(SD_LOCK_UNLOCK_FAILED);
2767 if((response_r1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
2769 return(SD_COM_CRC_FAILED);
2772 if((response_r1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
2774 return(SD_ILLEGAL_CMD);
2777 if((response_r1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
2779 return(SD_CARD_ECC_FAILED);
2782 if((response_r1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
2784 return(SD_CC_ERROR);
2787 if((response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
2789 return(SD_GENERAL_UNKNOWN_ERROR);
2792 if((response_r1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
2794 return(SD_STREAM_READ_UNDERRUN);
2797 if((response_r1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
2799 return(SD_STREAM_WRITE_OVERRUN);
2802 if((response_r1 & SD_OCR_CID_CSD_OVERWRIETE) == SD_OCR_CID_CSD_OVERWRIETE)
2804 return(SD_CID_CSD_OVERWRITE);
2807 if((response_r1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
2809 return(SD_WP_ERASE_SKIP);
2812 if((response_r1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
2814 return(SD_CARD_ECC_DISABLED);
2817 if((response_r1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
2819 return(SD_ERASE_RESET);
2822 if((response_r1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
2824 return(SD_AKE_SEQ_ERROR);
2831 * @brief Checks for error conditions for R3 (OCR) response.
2832 * @param hsd: SD handle
2833 * @retval SD Card error state
2835 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
2837 HAL_SD_ErrorTypedef errorstate = SD_OK;
2839 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2843 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2845 errorstate = SD_CMD_RSP_TIMEOUT;
2847 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2852 /* Clear all the static flags */
2853 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2859 * @brief Checks for error conditions for R2 (CID or CSD) response.
2860 * @param hsd: SD handle
2861 * @retval SD Card error state
2863 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
2865 HAL_SD_ErrorTypedef errorstate = SD_OK;
2867 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2871 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2873 errorstate = SD_CMD_RSP_TIMEOUT;
2875 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2879 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2881 errorstate = SD_CMD_CRC_FAIL;
2883 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2889 /* No error flag set */
2892 /* Clear all the static flags */
2893 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2899 * @brief Checks for error conditions for R6 (RCA) response.
2900 * @param hsd: SD handle
2901 * @param SD_CMD: The sent command index
2902 * @param pRCA: Pointer to the variable that will contain the SD card relative
2904 * @retval SD Card error state
2906 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
2908 HAL_SD_ErrorTypedef errorstate = SD_OK;
2909 uint32_t response_r1;
2911 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2915 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2917 errorstate = SD_CMD_RSP_TIMEOUT;
2919 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2923 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2925 errorstate = SD_CMD_CRC_FAIL;
2927 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2933 /* No error flag set */
2936 /* Check response received is of desired command */
2937 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2939 errorstate = SD_ILLEGAL_CMD;
2944 /* Clear all the static flags */
2945 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2947 /* We have received response, retrieve it. */
2948 response_r1 = SDIO_GetResponse(SDIO_RESP1);
2950 if((response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
2952 *pRCA = (uint16_t) (response_r1 >> 16);
2957 if((response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
2959 return(SD_GENERAL_UNKNOWN_ERROR);
2962 if((response_r1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
2964 return(SD_ILLEGAL_CMD);
2967 if((response_r1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
2969 return(SD_COM_CRC_FAILED);
2976 * @brief Enables the SDIO wide bus mode.
2977 * @param hsd: SD handle
2978 * @retval SD Card error state
2980 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
2982 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2983 HAL_SD_ErrorTypedef errorstate = SD_OK;
2985 uint32_t scr[2] = {0, 0};
2987 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
2989 errorstate = SD_LOCK_UNLOCK_FAILED;
2994 /* Get SCR Register */
2995 errorstate = SD_FindSCR(hsd, scr);
2997 if(errorstate != SD_OK)
3002 /* If requested card supports wide bus operation */
3003 if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
3005 /* Send CMD55 APP_CMD with argument as card's RCA.*/
3006 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3007 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3008 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3009 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3010 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3011 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3013 /* Check for error conditions */
3014 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3016 if(errorstate != SD_OK)
3021 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
3022 sdio_cmdinitstructure.Argument = 2;
3023 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
3024 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3026 /* Check for error conditions */
3027 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
3029 if(errorstate != SD_OK)
3038 errorstate = SD_REQUEST_NOT_APPLICABLE;
3045 * @brief Disables the SDIO wide bus mode.
3046 * @param hsd: SD handle
3047 * @retval SD Card error state
3049 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd)
3051 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3052 HAL_SD_ErrorTypedef errorstate = SD_OK;
3054 uint32_t scr[2] = {0, 0};
3056 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
3058 errorstate = SD_LOCK_UNLOCK_FAILED;
3063 /* Get SCR Register */
3064 errorstate = SD_FindSCR(hsd, scr);
3066 if(errorstate != SD_OK)
3071 /* If requested card supports 1 bit mode operation */
3072 if((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
3074 /* Send CMD55 APP_CMD with argument as card's RCA */
3075 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3076 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3077 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3078 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3079 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3080 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3082 /* Check for error conditions */
3083 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3085 if(errorstate != SD_OK)
3090 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
3091 sdio_cmdinitstructure.Argument = 0;
3092 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
3093 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3095 /* Check for error conditions */
3096 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
3098 if(errorstate != SD_OK)
3107 errorstate = SD_REQUEST_NOT_APPLICABLE;
3115 * @brief Finds the SD card SCR register value.
3116 * @param hsd: SD handle
3117 * @param pSCR: pointer to the buffer that will contain the SCR value
3118 * @retval SD Card error state
3120 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
3122 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3123 SDIO_DataInitTypeDef sdio_datainitstructure;
3124 HAL_SD_ErrorTypedef errorstate = SD_OK;
3126 uint32_t tempscr[2] = {0, 0};
3128 /* Set Block Size To 8 Bytes */
3129 /* Send CMD55 APP_CMD with argument as card's RCA */
3130 sdio_cmdinitstructure.Argument = (uint32_t)8;
3131 sdio_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
3132 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3133 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3134 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3135 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3137 /* Check for error conditions */
3138 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
3140 if(errorstate != SD_OK)
3145 /* Send CMD55 APP_CMD with argument as card's RCA */
3146 sdio_cmdinitstructure.Argument = (uint32_t)((hsd->RCA) << 16);
3147 sdio_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
3148 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3150 /* Check for error conditions */
3151 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
3153 if(errorstate != SD_OK)
3157 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
3158 sdio_datainitstructure.DataLength = 8;
3159 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
3160 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
3161 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
3162 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
3163 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
3165 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
3166 sdio_cmdinitstructure.Argument = 0;
3167 sdio_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_SEND_SCR;
3168 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3170 /* Check for error conditions */
3171 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_SEND_SCR);
3173 if(errorstate != SD_OK)
3178 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
3180 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
3182 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
3187 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
3189 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
3191 errorstate = SD_DATA_TIMEOUT;
3195 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
3197 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
3199 errorstate = SD_DATA_CRC_FAIL;
3203 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
3205 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
3207 errorstate = SD_RX_OVERRUN;
3211 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
3213 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
3215 errorstate = SD_START_BIT_ERR;
3221 /* No error flag set */
3224 /* Clear all the static flags */
3225 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
3227 *(pSCR + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) |\
3228 ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
3230 *(pSCR) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) |\
3231 ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
3237 * @brief Checks if the SD card is in programming state.
3238 * @param hsd: SD handle
3239 * @param pStatus: pointer to the variable that will contain the SD card state
3240 * @retval SD Card error state
3242 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus)
3244 SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3245 HAL_SD_ErrorTypedef errorstate = SD_OK;
3246 __IO uint32_t responseR1 = 0;
3248 sdio_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
3249 sdio_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
3250 sdio_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
3251 sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3252 sdio_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
3253 SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
3255 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
3259 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
3261 errorstate = SD_CMD_RSP_TIMEOUT;
3263 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
3267 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
3269 errorstate = SD_CMD_CRC_FAIL;
3271 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
3277 /* No error flag set */
3280 /* Check response received is of desired command */
3281 if((uint32_t)SDIO_GetCommandResponse(hsd->Instance) != SD_CMD_SEND_STATUS)
3283 errorstate = SD_ILLEGAL_CMD;
3288 /* Clear all the static flags */
3289 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
3292 /* We have received response, retrieve it for analysis */
3293 responseR1 = SDIO_GetResponse(SDIO_RESP1);
3295 /* Find out card status */
3296 *pStatus = (uint8_t)((responseR1 >> 9) & 0x0000000F);
3298 if((responseR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
3303 if((responseR1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
3305 return(SD_ADDR_OUT_OF_RANGE);
3308 if((responseR1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
3310 return(SD_ADDR_MISALIGNED);
3313 if((responseR1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
3315 return(SD_BLOCK_LEN_ERR);
3318 if((responseR1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
3320 return(SD_ERASE_SEQ_ERR);
3323 if((responseR1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
3325 return(SD_BAD_ERASE_PARAM);
3328 if((responseR1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
3330 return(SD_WRITE_PROT_VIOLATION);
3333 if((responseR1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
3335 return(SD_LOCK_UNLOCK_FAILED);
3338 if((responseR1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
3340 return(SD_COM_CRC_FAILED);
3343 if((responseR1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
3345 return(SD_ILLEGAL_CMD);
3348 if((responseR1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
3350 return(SD_CARD_ECC_FAILED);
3353 if((responseR1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
3355 return(SD_CC_ERROR);
3358 if((responseR1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
3360 return(SD_GENERAL_UNKNOWN_ERROR);
3363 if((responseR1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
3365 return(SD_STREAM_READ_UNDERRUN);
3368 if((responseR1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
3370 return(SD_STREAM_WRITE_OVERRUN);
3373 if((responseR1 & SD_OCR_CID_CSD_OVERWRIETE) == SD_OCR_CID_CSD_OVERWRIETE)
3375 return(SD_CID_CSD_OVERWRITE);
3378 if((responseR1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
3380 return(SD_WP_ERASE_SKIP);
3383 if((responseR1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
3385 return(SD_CARD_ECC_DISABLED);
3388 if((responseR1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
3390 return(SD_ERASE_RESET);
3393 if((responseR1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
3395 return(SD_AKE_SEQ_ERROR);
3405 #endif /* HAL_SD_MODULE_ENABLED */
3414 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/