2 ******************************************************************************
\r
3 * @file stm32f4xx_hal_sd.c
\r
4 * @author MCD Application Team
\r
6 * @date 18-February-2014
\r
7 * @brief SD card HAL module driver.
\r
8 * This file provides firmware functions to manage the following
\r
9 * functionalities of the Secure Digital (SD) peripheral:
\r
10 * + Initialization and de-initialization functions
\r
11 * + IO operation functions
\r
12 * + Peripheral Control functions
\r
13 * + Peripheral State functions
\r
16 ==============================================================================
\r
17 ##### How to use this driver #####
\r
18 ==============================================================================
\r
20 This driver implements a high level communication layer for read and write from/to
\r
21 this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by
\r
22 the user in HAL_SD_MspInit() function (MSP layer).
\r
23 Basically, the MSP layer configuration should be the same as we provide in the
\r
25 You can easily tailor this configuration according to hardware resources.
\r
28 This driver is a generic layered driver for SDIO memories which uses the HAL
\r
29 SDIO driver functions to interface with SD and uSD cards devices.
\r
30 It is used as follows:
\r
32 (#)Initialize the SDIO low level resources by implement the HAL_SD_MspInit() API:
\r
33 (##) Enable the SDIO interface clock using __SDIO_CLK_ENABLE();
\r
34 (##) SDIO pins configuration for SD card
\r
35 (+++) Enable the clock for the SDIO GPIOs using the functions __GPIOx_CLK_ENABLE();
\r
36 (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()
\r
37 and according to your pin assignment;
\r
38 (##) DMA Configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
\r
39 and HAL_SD_WriteBlocks_DMA() APIs).
\r
40 (+++) Enable the DMAx interface clock using __DMAx_CLK_ENABLE();
\r
41 (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.
\r
42 (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
\r
43 (+++) Configure the SDIO and DMA interrupt priorities using functions
\r
44 HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority
\r
45 (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()
\r
46 (+++) SDIO interrupts are managed using the macros __HAL_SD_SDIO_ENABLE_IT()
\r
47 and __HAL_SD_SDIO_DISABLE_IT() inside the communication process.
\r
48 (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_SDIO_GET_IT()
\r
49 and __HAL_SD_SDIO_CLEAR_IT()
\r
50 (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
\r
53 *** SD Card Initialization and configuration ***
\r
54 ================================================
\r
56 To initialize the SD Card, use the HAL_SD_Init() function. It Initializes
\r
57 the SD Card and put it into StandBy State (Ready for data transfer).
\r
58 This function provide the following operations:
\r
60 (#) Apply the SD Card initialization process at 400KHz and check the SD Card
\r
61 type (Standard Capacity or High Capacity). You can change or adapt this
\r
62 frequency by adjusting the "ClockDiv" field.
\r
63 The SD Card frequency (SDIO_CK) is computed as follows:
\r
65 SDIO_CK = SDIOCLK / (ClockDiv + 2)
\r
67 In initialization mode and according to the SD Card standard,
\r
68 make sure that the SDIO_CK frequency doesn't exceed 400KHz.
\r
70 (#) Get the SD CID and CSD data. All these information are managed by the SDCardInfo
\r
71 structure. This structure provide also ready computed SD Card capacity
\r
74 -@- These information are stored in SD handle structure in case of future use.
\r
76 (#) Configure the SD Card Data transfer frequency. By Default, the card transfer
\r
77 frequency is set to 24MHz. You can change or adapt this frequency by adjusting
\r
78 the "ClockDiv" field.
\r
79 The SD Card frequency (SDIO_CK) is computed as follows:
\r
81 SDIO_CK = SDIOCLK / (ClockDiv + 2)
\r
83 In transfer mode and according to the SD Card standard, make sure that the
\r
84 SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
\r
85 To be able to use a frequency higher than 24MHz, you should use the SDIO
\r
86 peripheral in bypass mode. Refer to the corresponding reference manual
\r
89 (#) Select the corresponding SD Card according to the address read with the step 2.
\r
91 (#) Configure the SD Card in wide bus mode: 4-bits data.
\r
93 *** SD Card Read operation ***
\r
94 ==============================
\r
96 (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
\r
97 This function support only 512-byte block length (the block size should be
\r
98 chosen as 512 byte).
\r
99 You can choose either one block read operation or multiple block read operation
\r
100 by adjusting the "NumberOfBlocks" parameter.
\r
102 (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
\r
103 This function support only 512-byte block length (the block size should be
\r
104 chosen as 512 byte).
\r
105 You can choose either one block read operation or multiple block read operation
\r
106 by adjusting the "NumberOfBlocks" parameter.
\r
107 After this, you have to call the function HAL_SD_CheckReadOperation(), to insure
\r
108 that the read transfer is done correctly in both DMA and SD sides.
\r
110 *** SD Card Write operation ***
\r
111 ===============================
\r
113 (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
\r
114 This function support only 512-byte block length (the block size should be
\r
115 chosen as 512 byte).
\r
116 You can choose either one block read operation or multiple block read operation
\r
117 by adjusting the "NumberOfBlocks" parameter.
\r
119 (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
\r
120 This function support only 512-byte block length (the block size should be
\r
121 chosen as 512 byte).
\r
122 You can choose either one block read operation or multiple block read operation
\r
123 by adjusting the "NumberOfBlocks" parameter.
\r
124 After this, you have to call the function HAL_SD_CheckWriteOperation(), to insure
\r
125 that the write transfer is done correctly in both DMA and SD sides.
\r
127 *** SD card status ***
\r
128 ======================
\r
130 (+) At any time, you can check the SD Card status and get the SD card state
\r
131 by using the HAL_SD_GetStatus() function. This function checks first if the
\r
132 SD card is still connected and then get the internal SD Card transfer state.
\r
133 (+) You can also get the SD card SD Status register by using the HAL_SD_SendSDStatus()
\r
136 *** SD HAL driver macros list ***
\r
137 ==================================
\r
139 Below the list of most used macros in SD HAL driver.
\r
141 (+) __HAL_SD_SDIO_ENABLE : Enable the SD device
\r
142 (+) __HAL_SD_SDIO_DISABLE : Disable the SD device
\r
143 (+) __HAL_SD_SDIO_DMA_ENABLE: Enable the SDIO DMA transfer
\r
144 (+) __HAL_SD_SDIO_DMA_DISABLE: Disable the SDIO DMA transfer
\r
145 (+) __HAL_SD_SDIO_ENABLE_IT: Enable the SD device interrupt
\r
146 (+) __HAL_SD_SDIO_DISABLE_IT: Disable the SD device interrupt
\r
147 (+) __HAL_SD_SDIO_GET_FLAG:Check whether the specified SD flag is set or not
\r
148 (+) __HAL_SD_SDIO_CLEAR_FLAG: Clear the SD's pending flags
\r
150 (@) You can refer to the SD HAL driver header file for more useful macros
\r
153 ******************************************************************************
\r
156 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
\r
158 * Redistribution and use in source and binary forms, with or without modification,
\r
159 * are permitted provided that the following conditions are met:
\r
160 * 1. Redistributions of source code must retain the above copyright notice,
\r
161 * this list of conditions and the following disclaimer.
\r
162 * 2. Redistributions in binary form must reproduce the above copyright notice,
\r
163 * this list of conditions and the following disclaimer in the documentation
\r
164 * and/or other materials provided with the distribution.
\r
165 * 3. Neither the name of STMicroelectronics nor the names of its contributors
\r
166 * may be used to endorse or promote products derived from this software
\r
167 * without specific prior written permission.
\r
169 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
\r
170 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
\r
171 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
\r
172 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
\r
173 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
\r
174 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
\r
175 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
\r
176 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
\r
177 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
\r
178 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
180 ******************************************************************************
\r
183 /* Includes ------------------------------------------------------------------*/
\r
184 #include "stm32f4xx_hal.h"
\r
186 /** @addtogroup STM32F4xx_HAL_Driver
\r
191 * @brief SD HAL module driver
\r
195 #ifdef HAL_SD_MODULE_ENABLED
\r
197 /* Private typedef -----------------------------------------------------------*/
\r
198 /* Private define ------------------------------------------------------------*/
\r
201 * @brief SDIO Static flags, TimeOut, FIFO Address
\r
203 #define SDIO_STATIC_FLAGS ((uint32_t)0x000005FF)
\r
204 #define SDIO_CMD0TIMEOUT ((uint32_t)0x00010000)
\r
207 * @brief Mask for errors Card Status R1 (OCR Register)
\r
209 #define SD_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000)
\r
210 #define SD_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000)
\r
211 #define SD_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000)
\r
212 #define SD_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000)
\r
213 #define SD_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000)
\r
214 #define SD_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000)
\r
215 #define SD_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000)
\r
216 #define SD_OCR_COM_CRC_FAILED ((uint32_t)0x00800000)
\r
217 #define SD_OCR_ILLEGAL_CMD ((uint32_t)0x00400000)
\r
218 #define SD_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000)
\r
219 #define SD_OCR_CC_ERROR ((uint32_t)0x00100000)
\r
220 #define SD_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000)
\r
221 #define SD_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000)
\r
222 #define SD_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000)
\r
223 #define SD_OCR_CID_CSD_OVERWRIETE ((uint32_t)0x00010000)
\r
224 #define SD_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000)
\r
225 #define SD_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000)
\r
226 #define SD_OCR_ERASE_RESET ((uint32_t)0x00002000)
\r
227 #define SD_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008)
\r
228 #define SD_OCR_ERRORBITS ((uint32_t)0xFDFFE008)
\r
231 * @brief Masks for R6 Response
\r
233 #define SD_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000)
\r
234 #define SD_R6_ILLEGAL_CMD ((uint32_t)0x00004000)
\r
235 #define SD_R6_COM_CRC_FAILED ((uint32_t)0x00008000)
\r
237 #define SD_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000)
\r
238 #define SD_HIGH_CAPACITY ((uint32_t)0x40000000)
\r
239 #define SD_STD_CAPACITY ((uint32_t)0x00000000)
\r
240 #define SD_CHECK_PATTERN ((uint32_t)0x000001AA)
\r
242 #define SD_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFF)
\r
243 #define SD_ALLZERO ((uint32_t)0x00000000)
\r
245 #define SD_WIDE_BUS_SUPPORT ((uint32_t)0x00040000)
\r
246 #define SD_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000)
\r
247 #define SD_CARD_LOCKED ((uint32_t)0x02000000)
\r
249 #define SD_DATATIMEOUT ((uint32_t)0xFFFFFFFF)
\r
250 #define SD_0TO7BITS ((uint32_t)0x000000FF)
\r
251 #define SD_8TO15BITS ((uint32_t)0x0000FF00)
\r
252 #define SD_16TO23BITS ((uint32_t)0x00FF0000)
\r
253 #define SD_24TO31BITS ((uint32_t)0xFF000000)
\r
254 #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFF)
\r
256 #define SD_HALFFIFO ((uint32_t)0x00000008)
\r
257 #define SD_HALFFIFOBYTES ((uint32_t)0x00000020)
\r
260 * @brief Command Class Supported
\r
262 #define SD_CCCC_LOCK_UNLOCK ((uint32_t)0x00000080)
\r
263 #define SD_CCCC_WRITE_PROT ((uint32_t)0x00000040)
\r
264 #define SD_CCCC_ERASE ((uint32_t)0x00000020)
\r
267 * @brief Following commands are SD Card Specific commands.
\r
268 * SDIO_APP_CMD should be sent before sending these commands.
\r
270 #define SD_SDIO_SEND_IF_COND ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
\r
273 /* Private macro -------------------------------------------------------------*/
\r
274 /* Private variables ---------------------------------------------------------*/
\r
275 /* Private function prototypes -----------------------------------------------*/
\r
276 /* Private functions ---------------------------------------------------------*/
\r
277 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
\r
278 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
\r
279 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd);
\r
280 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
\r
281 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
\r
282 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
\r
283 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
\r
284 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
\r
285 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
\r
286 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
\r
287 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
\r
288 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
\r
289 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
\r
290 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
\r
291 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
\r
292 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
\r
293 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
\r
294 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
\r
295 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
\r
296 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
\r
298 /** @defgroup SD_Private_Functions
\r
302 /** @defgroup SD_Group1 Initialization and de-initialization functions
\r
303 * @brief Initialization and Configuration functions
\r
306 ==============================================================================
\r
307 ##### Initialization and de-initialization functions #####
\r
308 ==============================================================================
\r
310 This section provides functions allowing to initialize/de-initialize the SD
\r
311 card device to be ready for use.
\r
319 * @brief Initializes the SD card according to the specified parameters in the
\r
320 SD_HandleTypeDef and create the associated handle.
\r
321 * @param hsd: SD handle
\r
322 * @param SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information
\r
323 * @retval HAL SD error state
\r
325 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
\r
327 __IO HAL_SD_ErrorTypedef errorState = SD_OK;
\r
328 SD_InitTypeDef tmpInit;
\r
330 /* Initialize the low level hardware (MSP) */
\r
331 HAL_SD_MspInit(hsd);
\r
333 /* Default SDIO peripheral configuration for SD card initialization */
\r
334 tmpInit.ClockEdge = SDIO_CLOCK_EDGE_RISING;
\r
335 tmpInit.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
\r
336 tmpInit.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
\r
337 tmpInit.BusWide = SDIO_BUS_WIDE_1B;
\r
338 tmpInit.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
\r
339 tmpInit.ClockDiv = SDIO_INIT_CLK_DIV;
\r
341 /* Initialize SDIO peripheral interface with default configuration */
\r
342 SDIO_Init(hsd->Instance, tmpInit);
\r
344 /* Identify card operating voltage */
\r
345 errorState = SD_PowerON(hsd);
\r
347 if(errorState != SD_OK)
\r
352 /* Initialize the present SDIO card(s) and put them in idle state */
\r
353 errorState = SD_Initialize_Cards(hsd);
\r
355 if (errorState != SD_OK)
\r
360 /* Read CSD/CID MSD registers */
\r
361 errorState = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
\r
363 if (errorState == SD_OK)
\r
365 /* Select the Card */
\r
366 errorState = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
\r
369 /* Configure SDIO peripheral interface */
\r
370 SDIO_Init(hsd->Instance, hsd->Init);
\r
376 * @brief De-Initializes the SD card.
\r
377 * @param hsd: SD handle
\r
378 * @retval HAL status
\r
380 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
\r
383 /* Set SD power state to off */
\r
386 /* De-Initialize the MSP layer */
\r
387 HAL_SD_MspDeInit(hsd);
\r
394 * @brief Initializes the SD MSP.
\r
395 * @param hsd: SD handle
\r
398 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
\r
400 /* NOTE : This function Should not be modified, when the callback is needed,
\r
401 the HAL_SD_MspInit could be implemented in the user file
\r
406 * @brief De-Initialize SD MSP.
\r
407 * @param hsd: SD handle
\r
410 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
\r
412 /* NOTE : This function Should not be modified, when the callback is needed,
\r
413 the HAL_SD_MspDeInit could be implemented in the user file
\r
421 /** @defgroup SD_Group2 IO operation functions
\r
422 * @brief Data transfer functions
\r
425 ==============================================================================
\r
426 ##### IO operation functions #####
\r
427 ==============================================================================
\r
429 This subsection provides a set of functions allowing to manage the data
\r
430 transfer from/to SD card.
\r
437 * @brief Reads block(s) from a specified address in a card. The Data transfer
\r
438 * is managed by polling mode.
\r
439 * @param hsd: SD handle
\r
440 * @param pReadBuffer: pointer to the buffer that will contain the received data
\r
441 * @param ReadAddr: Address from where data is to be read
\r
442 * @param BlockSize: SD card Data block size
\r
443 * This parameter should be 512
\r
444 * @param NumberOfBlocks: Number of SD blocks to read
\r
445 * @retval SD Card error state
\r
447 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
449 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
450 SDIO_DataInitTypeDef SDIO_DataInitStructure;
\r
451 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
452 uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
\r
454 /* Initialize data control register */
\r
455 hsd->Instance->DCTRL = 0;
\r
457 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
463 /* Set Block Size for Card */
\r
464 SDIO_CmdInitStructure.Argument = (uint32_t) BlockSize;
\r
465 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
466 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
467 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
468 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
469 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
471 /* Check for error conditions */
\r
472 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
474 if (errorState != SD_OK)
\r
479 /* Configure the SD DPSM (Data Path State Machine) */
\r
480 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
\r
481 SDIO_DataInitStructure.DataLength = NumberOfBlocks * BlockSize;
\r
482 SDIO_DataInitStructure.DataBlockSize = (uint32_t)(9 << 4);
\r
483 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
484 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
485 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
\r
486 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
\r
488 if(NumberOfBlocks > 1)
\r
490 /* Send CMD18 READ_MULT_BLOCK with argument data address */
\r
491 SDIO_CmdInitStructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
\r
495 /* Send CMD17 READ_SINGLE_BLOCK */
\r
496 SDIO_CmdInitStructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
\r
499 SDIO_CmdInitStructure.Argument = (uint32_t)ReadAddr;
\r
500 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
502 /* Read block(s) in polling mode */
\r
503 if(NumberOfBlocks > 1)
\r
505 /* Check for error conditions */
\r
506 errorState = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
\r
508 if (errorState != SD_OK)
\r
513 /* Poll on SDIO flags */
\r
514 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
\r
516 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
518 /* Read data from SDIO Rx FIFO */
\r
519 for (count = 0; count < 8; count++)
\r
521 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
\r
530 /* Check for error conditions */
\r
531 errorState = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
\r
533 if (errorState != SD_OK)
\r
538 /* In case of single block transfer, no need of stop transfer at all */
\r
539 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
\r
541 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
543 /* Read data from SDIO Rx FIFO */
\r
544 for (count = 0; count < 8; count++)
\r
546 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
\r
554 /* Send stop transmission command in case of multiblock read */
\r
555 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
\r
557 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
\r
558 (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
559 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
561 /* Send stop transmission command */
\r
562 errorState = HAL_SD_StopTransfer(hsd);
\r
566 /* Get error state */
\r
567 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
569 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
571 errorState = SD_DATA_TIMEOUT;
\r
575 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
577 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
579 errorState = SD_DATA_CRC_FAIL;
\r
583 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
585 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
587 errorState = SD_RX_OVERRUN;
\r
591 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
\r
593 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
\r
595 errorState = SD_START_BIT_ERR;
\r
600 count = SD_DATATIMEOUT;
\r
602 /* Empty FIFO if there is still any data */
\r
603 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
\r
605 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
\r
610 /* Clear all the static flags */
\r
611 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
617 * @brief Allows to write block(s) to a specified address in a card. The Data
\r
618 * transfer is managed by polling mode.
\r
619 * @param hsd: SD handle
\r
620 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
\r
621 * @param WriteAddr: Address from where data is to be written
\r
622 * @param BlockSize: SD card Data block size
\r
623 * This parameter should be 512.
\r
624 * @param NumberOfBlocks: Number of SD blocks to write
\r
625 * @retval SD Card error state
\r
627 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
629 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
630 SDIO_DataInitTypeDef SDIO_DataInitStructure;
\r
631 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
632 uint32_t TotalNumberOfBytes = 0, bytestransferred = 0, count = 0, restwords = 0;
\r
633 uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
\r
634 uint8_t cardstate = 0;
\r
636 /* Initialize data control register */
\r
637 hsd->Instance->DCTRL = 0;
\r
639 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
645 /* Set Block Size for Card */
\r
646 SDIO_CmdInitStructure.Argument = (uint32_t)BlockSize;
\r
647 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
648 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
649 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
650 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
651 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
653 /* Check for error conditions */
\r
654 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
656 if (errorState != SD_OK)
\r
661 if(NumberOfBlocks > 1)
\r
663 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
\r
664 SDIO_CmdInitStructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
\r
668 /* Send CMD24 WRITE_SINGLE_BLOCK */
\r
669 SDIO_CmdInitStructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
\r
672 SDIO_CmdInitStructure.Argument = (uint32_t)WriteAddr;
\r
673 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
675 /* Check for error conditions */
\r
676 if(NumberOfBlocks > 1)
\r
678 errorState = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
\r
682 errorState = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
\r
685 if (errorState != SD_OK)
\r
690 /* Set total number of bytes to write */
\r
691 TotalNumberOfBytes = NumberOfBlocks * BlockSize;
\r
693 /* Configure the SD DPSM (Data Path State Machine) */
\r
694 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
\r
695 SDIO_DataInitStructure.DataLength = NumberOfBlocks * BlockSize;
\r
696 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
\r
697 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
\r
698 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
699 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
\r
700 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
\r
702 /* Write block(s) in polling mode */
\r
703 if(NumberOfBlocks > 1)
\r
705 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
\r
707 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
\r
709 if ((TotalNumberOfBytes - bytestransferred) < 32)
\r
711 restwords = ((TotalNumberOfBytes - bytestransferred) % 4 == 0) ? ((TotalNumberOfBytes - bytestransferred) / 4) : (( TotalNumberOfBytes - bytestransferred) / 4 + 1);
\r
713 /* Write data to SDIO Tx FIFO */
\r
714 for (count = 0; count < restwords; count++)
\r
716 SDIO_WriteFIFO(hsd->Instance, tempbuff);
\r
718 bytestransferred += 4;
\r
723 /* Write data to SDIO Tx FIFO */
\r
724 for (count = 0; count < 8; count++)
\r
726 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
\r
730 bytestransferred += 32;
\r
737 /* In case of single data block transfer no need of stop command at all */
\r
738 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
\r
740 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
\r
742 if ((TotalNumberOfBytes - bytestransferred) < 32)
\r
744 restwords = ((TotalNumberOfBytes - bytestransferred) % 4 == 0) ? ((TotalNumberOfBytes - bytestransferred) / 4) : (( TotalNumberOfBytes - bytestransferred) / 4 + 1);
\r
746 /* Write data to SDIO Tx FIFO */
\r
747 for (count = 0; count < restwords; count++)
\r
749 SDIO_WriteFIFO(hsd->Instance, tempbuff);
\r
751 bytestransferred += 4;
\r
756 /* Write data to SDIO Tx FIFO */
\r
757 for (count = 0; count < 8; count++)
\r
759 SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
\r
763 bytestransferred += 32;
\r
769 /* Send stop transmission command in case of multiblock write */
\r
770 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
\r
772 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
773 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
775 /* Send stop transmission command */
\r
776 errorState = HAL_SD_StopTransfer(hsd);
\r
780 /* Get error state */
\r
781 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
783 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
785 errorState = SD_DATA_TIMEOUT;
\r
789 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
791 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
793 errorState = SD_DATA_CRC_FAIL;
\r
797 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
\r
799 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
\r
801 errorState = SD_TX_UNDERRUN;
\r
805 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
\r
807 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
\r
809 errorState = SD_START_BIT_ERR;
\r
814 /* Clear all the static flags */
\r
815 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
817 /* Wait till the card is in programming state */
\r
818 errorState = SD_IsCardProgramming(hsd, &cardstate);
\r
820 while ((errorState == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
\r
822 errorState = SD_IsCardProgramming(hsd, &cardstate);
\r
829 * @brief Reads block(s) from a specified address in a card. The Data transfer
\r
830 * is managed by DMA mode.
\r
831 * @note This API should be followed by the function HAL_SD_CheckReadOperation()
\r
832 * to check the completion of the read process
\r
833 * @param hsd: SD handle
\r
834 * @param pReadBuffer: Pointer to the buffer that will contain the received data
\r
835 * @param ReadAddr: Address from where data is to be read
\r
836 * @param BlockSize: SD card Data block size
\r
837 * This paramater should be 512.
\r
838 * @param NumberOfBlocks: Number of blocks to read.
\r
839 * @retval SD Card error state
\r
841 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
843 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
844 SDIO_DataInitTypeDef SDIO_DataInitStructure;
\r
845 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
847 /* Initialize data control register */
\r
848 hsd->Instance->DCTRL = 0;
\r
850 /* Initialize handle flags */
\r
851 hsd->SdTransferCplt = 0;
\r
852 hsd->DmaTransferCplt = 0;
\r
853 hsd->SdTransferErr = SD_OK;
\r
855 /* Initialize SD Read operation */
\r
856 if(NumberOfBlocks > 1)
\r
858 hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
\r
862 hsd->SdOperation = SD_READ_SINGLE_BLOCK;
\r
865 /* Enable transfer interrupts */
\r
866 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
\r
867 SDIO_IT_DTIMEOUT |\
\r
870 SDIO_IT_STBITERR));
\r
872 /* Enable SDIO DMA transfer */
\r
873 __HAL_SD_SDIO_DMA_ENABLE();
\r
875 /* Configure DMA user callbacks */
\r
876 hsd->hdmarx->XferCpltCallback = SD_DMA_RxCplt;
\r
877 hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
\r
879 /* Enable the DMA Stream */
\r
880 HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)SDIO_FIFO_ADDRESS, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks));
\r
882 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
888 /* Set Block Size for Card */
\r
889 SDIO_CmdInitStructure.Argument = (uint32_t)BlockSize;
\r
890 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
891 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
892 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
893 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
894 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
896 /* Check for error conditions */
\r
897 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
899 if (errorState != SD_OK)
\r
904 /* Configure the SD DPSM (Data Path State Machine) */
\r
905 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
\r
906 SDIO_DataInitStructure.DataLength = BlockSize * NumberOfBlocks;
\r
907 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
\r
908 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
909 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
910 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
\r
911 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
\r
913 /* Check number of blocks command */
\r
914 if(NumberOfBlocks > 1)
\r
916 /* Send CMD18 READ_MULT_BLOCK with argument data address */
\r
917 SDIO_CmdInitStructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
\r
921 /* Send CMD17 READ_SINGLE_BLOCK */
\r
922 SDIO_CmdInitStructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
\r
925 SDIO_CmdInitStructure.Argument = (uint32_t)ReadAddr;
\r
926 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
928 /* Check for error conditions */
\r
929 if(NumberOfBlocks > 1)
\r
931 errorState = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
\r
935 errorState = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
\r
938 /* Update the SD transfer error in SD handle */
\r
939 hsd->SdTransferErr = errorState;
\r
946 * @brief Writes block(s) to a specified address in a card. The Data transfer
\r
947 * is managed by DMA mode.
\r
948 * @note This API should be followed by the function HAL_SD_CheckWriteOperation()
\r
949 * to check the completion of the write process (by SD current status polling).
\r
950 * @param hsd: SD handle
\r
951 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
\r
952 * @param WriteAddr: Address from where data is to be read
\r
953 * @param BlockSize: the SD card Data block size
\r
954 * This parameter should be 512.
\r
955 * @param NumberOfBlocks: Number of blocks to write
\r
956 * @retval SD Card error state
\r
958 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
960 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
961 SDIO_DataInitTypeDef SDIO_DataInitStructure;
\r
962 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
964 /* Initialize data control register */
\r
965 hsd->Instance->DCTRL = 0;
\r
967 /* Initialize handle flags */
\r
968 hsd->SdTransferCplt = 0;
\r
969 hsd->DmaTransferCplt = 0;
\r
970 hsd->SdTransferErr = SD_OK;
\r
972 /* Initialize SD Write operation */
\r
973 if(NumberOfBlocks > 1)
\r
975 hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
\r
979 hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
\r
982 /* Enable transfer interrupts */
\r
983 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
\r
984 SDIO_IT_DTIMEOUT |\
\r
986 SDIO_IT_TXUNDERR |\
\r
987 SDIO_IT_STBITERR));
\r
989 /* Configure DMA user callbacks */
\r
990 hsd->hdmatx->XferCpltCallback = SD_DMA_TxCplt;
\r
991 hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
\r
993 /* Enable the DMA Stream */
\r
994 HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)SDIO_FIFO_ADDRESS, (uint32_t)(BlockSize * NumberOfBlocks));
\r
996 /* Enable SDIO DMA transfer */
\r
997 __HAL_SD_SDIO_DMA_ENABLE();
\r
999 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
1005 /* Set Block Size for Card */
\r
1006 SDIO_CmdInitStructure.Argument = (uint32_t)BlockSize;
\r
1007 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
1008 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
1009 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1010 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
1011 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1013 /* Check for error conditions */
\r
1014 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
1016 if (errorState != SD_OK)
\r
1018 return errorState;
\r
1021 /* Check number of blocks command */
\r
1022 if(NumberOfBlocks <= 1)
\r
1024 /* Send CMD24 WRITE_SINGLE_BLOCK */
\r
1025 SDIO_CmdInitStructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
\r
1029 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
\r
1030 SDIO_CmdInitStructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
\r
1033 SDIO_CmdInitStructure.Argument = (uint32_t)WriteAddr;
\r
1034 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1036 /* Check for error conditions */
\r
1037 if(NumberOfBlocks > 1)
\r
1039 errorState = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
\r
1043 errorState = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
\r
1046 if (errorState != SD_OK)
\r
1048 return errorState;
\r
1051 /* Configure the SD DPSM (Data Path State Machine) */
\r
1052 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
\r
1053 SDIO_DataInitStructure.DataLength = BlockSize * NumberOfBlocks;
\r
1054 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
\r
1055 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
\r
1056 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
1057 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
\r
1058 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
\r
1060 hsd->SdTransferErr = errorState;
\r
1062 return errorState;
\r
1066 * @brief This function waits until the SD DMA data read transfer is finished.
\r
1067 * This API should be called after HAL_SD_ReadBlocks_DMA() function
\r
1068 * to insure that all data sent by the card is already transferred by the
\r
1070 * @param hsd: SD handle
\r
1071 * @param Timeout: Timeout duration
\r
1072 * @retval SD Card error state
\r
1074 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
\r
1076 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1077 uint32_t timeout = Timeout;
\r
1078 uint32_t tmp1, tmp2;
\r
1079 HAL_SD_ErrorTypedef tmp3;
\r
1081 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
\r
1082 tmp1 = hsd->DmaTransferCplt;
\r
1083 tmp2 = hsd->SdTransferCplt;
\r
1084 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
\r
1086 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
\r
1088 tmp1 = hsd->DmaTransferCplt;
\r
1089 tmp2 = hsd->SdTransferCplt;
\r
1090 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
\r
1094 timeout = Timeout;
\r
1096 /* Wait until the Rx transfer is no longer active */
\r
1097 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXACT)) && (timeout > 0))
\r
1102 /* Send stop command in multiblock read */
\r
1103 if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
\r
1105 errorState = HAL_SD_StopTransfer(hsd);
\r
1108 if ((timeout == 0) && (errorState == SD_OK))
\r
1110 errorState = SD_DATA_TIMEOUT;
\r
1113 /* Clear all the static flags */
\r
1114 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
1116 /* Return error state */
\r
1117 if (hsd->SdTransferErr != SD_OK)
\r
1119 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
\r
1122 return errorState;
\r
1126 * @brief This function waits until the SD DMA data write transfer is finished.
\r
1127 * This API should be called after HAL_SD_WriteBlocks_DMA() function
\r
1128 * to insure that all data sent by the card is already transferred by the
\r
1130 * @param hsd: SD handle
\r
1131 * @param Timeout: Timeout duration
\r
1132 * @retval SD Card error state
\r
1134 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
\r
1136 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1137 uint32_t timeout = Timeout;
\r
1138 uint32_t tmp1, tmp2;
\r
1139 HAL_SD_ErrorTypedef tmp3;
\r
1141 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
\r
1142 tmp1 = hsd->DmaTransferCplt;
\r
1143 tmp2 = hsd->SdTransferCplt;
\r
1144 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
\r
1146 while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
\r
1148 tmp1 = hsd->DmaTransferCplt;
\r
1149 tmp2 = hsd->SdTransferCplt;
\r
1150 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
\r
1154 timeout = Timeout;
\r
1156 /* Wait until the Tx transfer is no longer active */
\r
1157 while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXACT)) && (timeout > 0))
\r
1162 /* Send stop command in multiblock write */
\r
1163 if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
\r
1165 errorState = HAL_SD_StopTransfer(hsd);
\r
1168 if ((timeout == 0) && (errorState == SD_OK))
\r
1170 errorState = SD_DATA_TIMEOUT;
\r
1173 /* Clear all the static flags */
\r
1174 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
1176 /* Return error state */
\r
1177 if (hsd->SdTransferErr != SD_OK)
\r
1179 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
\r
1182 /* Wait until write is complete */
\r
1183 while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
\r
1187 return errorState;
\r
1191 * @brief Erases the specified memory area of the given SD card.
\r
1192 * @param hsd: SD handle
\r
1193 * @param startaddr: Start byte address
\r
1194 * @param endaddr: End byte address
\r
1195 * @retval SD Card error state
\r
1197 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
\r
1199 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1200 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
1202 uint32_t delay = 0;
\r
1203 __IO uint32_t maxdelay = 0;
\r
1204 uint8_t cardstate = 0;
\r
1206 /* Check if the card command class supports erase command */
\r
1207 if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
\r
1209 errorState = SD_REQUEST_NOT_APPLICABLE;
\r
1211 return errorState;
\r
1214 /* Get max delay value */
\r
1215 maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
\r
1217 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
1219 errorState = SD_LOCK_UNLOCK_FAILED;
\r
1221 return errorState;
\r
1224 /* Get start and end block for high capacity cards */
\r
1225 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
1231 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
\r
1232 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
1233 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
1235 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
\r
1236 SDIO_CmdInitStructure.Argument =(uint32_t)startaddr;
\r
1237 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_ERASE_GRP_START;
\r
1238 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
1239 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1240 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
1241 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1243 /* Check for error conditions */
\r
1244 errorState = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
\r
1246 if (errorState != SD_OK)
\r
1248 return errorState;
\r
1251 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
\r
1252 SDIO_CmdInitStructure.Argument = (uint32_t)endaddr;
\r
1253 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_ERASE_GRP_END;
\r
1254 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1256 /* Check for error conditions */
\r
1257 errorState = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
\r
1259 if (errorState != SD_OK)
\r
1261 return errorState;
\r
1265 /* Send CMD38 ERASE */
\r
1266 SDIO_CmdInitStructure.Argument = 0;
\r
1267 SDIO_CmdInitStructure.CmdIndex = SD_CMD_ERASE;
\r
1268 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1270 /* Check for error conditions */
\r
1271 errorState = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
\r
1273 if (errorState != SD_OK)
\r
1275 return errorState;
\r
1278 for (; delay < maxdelay; delay++)
\r
1282 /* Wait untill the card is in programming state */
\r
1283 errorState = SD_IsCardProgramming(hsd, &cardstate);
\r
1285 delay = SD_DATATIMEOUT;
\r
1287 while ((delay > 0) && (errorState == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
\r
1289 errorState = SD_IsCardProgramming(hsd, &cardstate);
\r
1293 return errorState;
\r
1297 * @brief This function handles SD card interrupt request.
\r
1298 * @param hsd: SD handle
\r
1301 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
\r
1303 /* Check for SDIO interrupt flags */
\r
1304 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DATAEND))
\r
1306 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_IT_DATAEND);
\r
1308 /* SD transfer is complete */
\r
1309 hsd->SdTransferCplt = 1;
\r
1311 /* No transfer error */
\r
1312 hsd->SdTransferErr = SD_OK;
\r
1314 HAL_SD_XferCpltCallback(hsd);
\r
1316 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DCRCFAIL))
\r
1318 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
1320 hsd->SdTransferErr = SD_DATA_CRC_FAIL;
\r
1322 HAL_SD_XferErrorCallback(hsd);
\r
1325 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DTIMEOUT))
\r
1327 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
1329 hsd->SdTransferErr = SD_DATA_TIMEOUT;
\r
1331 HAL_SD_XferErrorCallback(hsd);
\r
1333 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_RXOVERR))
\r
1335 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
1337 hsd->SdTransferErr = SD_RX_OVERRUN;
\r
1339 HAL_SD_XferErrorCallback(hsd);
\r
1341 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_TXUNDERR))
\r
1343 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
\r
1345 hsd->SdTransferErr = SD_TX_UNDERRUN;
\r
1347 HAL_SD_XferErrorCallback(hsd);
\r
1349 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_STBITERR))
\r
1351 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
\r
1353 hsd->SdTransferErr = SD_START_BIT_ERR;
\r
1355 HAL_SD_XferErrorCallback(hsd);
\r
1358 /* Disable all SDIO peripheral interrupt sources */
\r
1359 __HAL_SD_SDIO_DISABLE_IT(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |\
\r
1360 SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |\
\r
1361 SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
\r
1366 * @brief SD end of transfer callback.
\r
1367 * @param hsd: SD handle
\r
1370 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
\r
1372 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1373 the HAL_SD_XferCpltCallback could be implemented in the user file
\r
1378 * @brief SD Transfer Error callback.
\r
1379 * @param hsd: SD handle
\r
1382 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
\r
1384 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1385 the HAL_SD_XferErrorCallback could be implemented in the user file
\r
1390 * @brief SD Transfer complete Rx callback in non blocking mode.
\r
1391 * @param hdma: DMA handle
\r
1394 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
\r
1396 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1397 the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
\r
1402 * @brief SD DMA transfer complete Rx error callback.
\r
1403 * @param hdma: DMA handle
\r
1406 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
\r
1408 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1409 the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
\r
1414 * @brief SD Transfer complete Tx callback in non blocking mode.
\r
1415 * @param hdma: DMA handle
\r
1418 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
\r
1420 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1421 the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
\r
1426 * @brief SD DMA transfer complete error Tx callback.
\r
1427 * @param hdma: DMA handle
\r
1430 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
\r
1432 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1433 the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
\r
1441 /** @defgroup SD_Group3 Peripheral Control functions
\r
1442 * @brief management functions
\r
1445 ==============================================================================
\r
1446 ##### Peripheral Control functions #####
\r
1447 ==============================================================================
\r
1449 This subsection provides a set of functions allowing to control the SD card
\r
1457 * @brief Returns information about specific card.
\r
1458 * @param hsd: SD handle
\r
1459 * @param pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
\r
1460 * contains all SD cardinformation
\r
1461 * @retval SD Card error state
\r
1463 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
\r
1465 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1468 pCardInfo->CardType = (uint8_t)(hsd->CardType);
\r
1469 pCardInfo->RCA = (uint16_t)(hsd->RCA);
\r
1472 tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
\r
1473 pCardInfo->SD_csd.CSDStruct = (uint8_t)((tmp & 0xC0) >> 6);
\r
1474 pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
\r
1475 pCardInfo->SD_csd.Reserved1 = tmp & 0x03;
\r
1478 tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
\r
1479 pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
\r
1482 tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
\r
1483 pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
\r
1486 tmp = hsd->CSD[0] & 0x000000FF;
\r
1487 pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
\r
1490 tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
\r
1491 pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
\r
1494 tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
\r
1495 pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
\r
1496 pCardInfo->SD_csd.RdBlockLen = (uint8_t)(tmp & 0x0F);
\r
1499 tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
\r
1500 pCardInfo->SD_csd.PartBlockRead = (uint8_t)((tmp & 0x80) >> 7);
\r
1501 pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
\r
1502 pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
\r
1503 pCardInfo->SD_csd.DSRImpl = (uint8_t)((tmp & 0x10) >> 4);
\r
1504 pCardInfo->SD_csd.Reserved2 = 0; /*!< Reserved */
\r
1506 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
\r
1508 pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
\r
1511 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
\r
1512 pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
\r
1515 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
\r
1516 pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
\r
1518 pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
\r
1519 pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
\r
1522 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
\r
1523 pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
\r
1524 pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
\r
1525 pCardInfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
\r
1527 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
\r
1528 pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
\r
1530 pCardInfo->CardCapacity = (pCardInfo->SD_csd.DeviceSize + 1) ;
\r
1531 pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
\r
1532 pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
\r
1533 pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
\r
1535 else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
1538 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
\r
1539 pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
\r
1542 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
\r
1544 pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
\r
1547 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
\r
1549 pCardInfo->SD_csd.DeviceSize |= (tmp);
\r
1552 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
\r
1554 pCardInfo->CardCapacity = ((pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024;
\r
1555 pCardInfo->CardBlockSize = 512;
\r
1558 pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
\r
1559 pCardInfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
\r
1562 tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
\r
1563 pCardInfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
\r
1564 pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
\r
1567 tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
\r
1568 pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
\r
1569 pCardInfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
\r
1570 pCardInfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
\r
1571 pCardInfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
\r
1574 tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
\r
1575 pCardInfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
\r
1576 pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
\r
1577 pCardInfo->SD_csd.Reserved3 = 0;
\r
1578 pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
\r
1581 tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
\r
1582 pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
\r
1583 pCardInfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
\r
1584 pCardInfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
\r
1585 pCardInfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
\r
1586 pCardInfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
\r
1587 pCardInfo->SD_csd.ECC = (tmp & 0x03);
\r
1590 tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
\r
1591 pCardInfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
\r
1592 pCardInfo->SD_csd.Reserved4 = 1;
\r
1595 tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
\r
1596 pCardInfo->SD_cid.ManufacturerID = tmp;
\r
1599 tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
\r
1600 pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
\r
1603 tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
\r
1604 pCardInfo->SD_cid.OEM_AppliID |= tmp;
\r
1607 tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
\r
1608 pCardInfo->SD_cid.ProdName1 = tmp << 24;
\r
1611 tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
\r
1612 pCardInfo->SD_cid.ProdName1 |= tmp << 16;
\r
1615 tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
\r
1616 pCardInfo->SD_cid.ProdName1 |= tmp << 8;
\r
1619 tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
\r
1620 pCardInfo->SD_cid.ProdName1 |= tmp;
\r
1623 tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
\r
1624 pCardInfo->SD_cid.ProdName2 = tmp;
\r
1627 tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
\r
1628 pCardInfo->SD_cid.ProdRev = tmp;
\r
1631 tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
\r
1632 pCardInfo->SD_cid.ProdSN = tmp << 24;
\r
1635 tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
\r
1636 pCardInfo->SD_cid.ProdSN |= tmp << 16;
\r
1639 tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
\r
1640 pCardInfo->SD_cid.ProdSN |= tmp << 8;
\r
1643 tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
\r
1644 pCardInfo->SD_cid.ProdSN |= tmp;
\r
1647 tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
\r
1648 pCardInfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
\r
1649 pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
\r
1652 tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
\r
1653 pCardInfo->SD_cid.ManufactDate |= tmp;
\r
1656 tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
\r
1657 pCardInfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
\r
1658 pCardInfo->SD_cid.Reserved2 = 1;
\r
1660 return errorState;
\r
1664 * @brief Enables wide bus operation for the requested card if supported by
\r
1666 * @param hsd: SD handle
\r
1667 * @param WideMode: Specifies the SD card wide bus mode
\r
1668 * This parameter can be one of the following values:
\r
1669 * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
\r
1670 * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
\r
1671 * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
\r
1672 * @retval SD Card error state
\r
1674 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
\r
1676 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1677 SDIO_InitTypeDef Init;
\r
1679 /* MMC Card does not support this feature */
\r
1680 if (hsd->CardType == MULTIMEDIA_CARD)
\r
1682 errorState = SD_UNSUPPORTED_FEATURE;
\r
1684 return errorState;
\r
1686 else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
1687 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
1689 if (WideMode == SDIO_BUS_WIDE_8B)
\r
1691 errorState = SD_UNSUPPORTED_FEATURE;
\r
1693 return errorState;
\r
1695 else if (WideMode == SDIO_BUS_WIDE_4B)
\r
1697 errorState = SD_WideBus_Enable(hsd);
\r
1699 if (errorState == SD_OK)
\r
1701 /* Configure the SDIO peripheral */
\r
1702 Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
\r
1703 Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
\r
1704 Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
\r
1705 Init.BusWide = SDIO_BUS_WIDE_4B;
\r
1706 Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
\r
1707 Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;
\r
1709 /* Configure SDIO peripheral interface */
\r
1710 SDIO_Init(hsd->Instance, Init);
\r
1715 errorState = SD_WideBus_Disable(hsd);
\r
1717 if (errorState == SD_OK)
\r
1719 /* Configure the SDIO peripheral */
\r
1720 Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
\r
1721 Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
\r
1722 Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
\r
1723 Init.BusWide = SDIO_BUS_WIDE_1B;
\r
1724 Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
\r
1725 Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;
\r
1727 /* Configure SDIO peripheral interface */
\r
1728 SDIO_Init(hsd->Instance, Init);
\r
1733 return errorState;
\r
1737 * @brief Aborts an ongoing data transfer.
\r
1738 * @param hsd: SD handle
\r
1739 * @retval SD Card error state
\r
1741 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
\r
1743 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
1744 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1746 /* Send CMD12 STOP_TRANSMISSION */
\r
1747 SDIO_CmdInitStructure.Argument = 0;
\r
1748 SDIO_CmdInitStructure.CmdIndex = SD_CMD_STOP_TRANSMISSION;
\r
1749 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
1750 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1751 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
1752 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1754 /* Check for error conditions */
\r
1755 errorState = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
\r
1757 return errorState;
\r
1761 * @brief Switches the SD card to High Speed mode.
\r
1762 * This API must be used after "Transfer State"
\r
1763 * @note This operation should be followed by the configuration
\r
1764 * of PLL to have SDIOCK clock between 67 and 75 MHz
\r
1765 * @param hsd: SD handle
\r
1766 * @retval SD Card error state
\r
1768 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
\r
1770 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1771 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
1772 SDIO_DataInitTypeDef SDIO_DataInitStructure;
\r
1774 uint8_t SD_hs[64] = {0};
\r
1775 uint32_t SD_scr[2] = {0, 0};
\r
1776 uint32_t SD_SPEC = 0 ;
\r
1777 uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
\r
1779 /* Initialize the Data control register */
\r
1780 hsd->Instance->DCTRL = 0;
\r
1782 /* Get SCR Register */
\r
1783 errorState = SD_FindSCR(hsd, SD_scr);
\r
1785 if (errorState != SD_OK)
\r
1787 return errorState;
\r
1790 /* Test the Version supported by the card*/
\r
1791 SD_SPEC = (SD_scr[1] & 0x01000000) | (SD_scr[1] & 0x02000000);
\r
1793 if (SD_SPEC != SD_ALLZERO)
\r
1795 /* Set Block Size for Card */
\r
1796 SDIO_CmdInitStructure.Argument = (uint32_t)64;
\r
1797 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
1798 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
1799 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1800 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
1801 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1803 /* Check for error conditions */
\r
1804 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
1806 if (errorState != SD_OK)
\r
1808 return errorState;
\r
1811 /* Configure the SD DPSM (Data Path State Machine) */
\r
1812 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
\r
1813 SDIO_DataInitStructure.DataLength = 64;
\r
1814 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
\r
1815 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
1816 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
1817 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
\r
1818 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
\r
1820 /* Send CMD6 switch mode */
\r
1821 SDIO_CmdInitStructure.Argument = 0x80FFFF01;
\r
1822 SDIO_CmdInitStructure.CmdIndex = SD_CMD_HS_SWITCH;
\r
1823 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1825 /* Check for error conditions */
\r
1826 errorState = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
\r
1828 if (errorState != SD_OK)
\r
1830 return errorState;
\r
1833 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
\r
1835 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
1837 for (count = 0; count < 8; count++)
\r
1839 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
\r
1846 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
1848 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
1850 errorState = SD_DATA_TIMEOUT;
\r
1852 return errorState;
\r
1854 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
1856 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
1858 errorState = SD_DATA_CRC_FAIL;
\r
1860 return errorState;
\r
1862 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
1864 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
1866 errorState = SD_RX_OVERRUN;
\r
1868 return errorState;
\r
1870 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
\r
1872 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
\r
1874 errorState = SD_START_BIT_ERR;
\r
1876 return errorState;
\r
1879 count = SD_DATATIMEOUT;
\r
1881 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
\r
1883 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
\r
1888 /* Clear all the static flags */
\r
1889 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
1891 /* Test if the switch mode HS is ok */
\r
1892 if ((SD_hs[13]& 2) != 2)
\r
1894 errorState = SD_UNSUPPORTED_FEATURE;
\r
1898 return errorState;
\r
1905 /** @defgroup SD_Group4 Peripheral State functions
\r
1906 * @brief Peripheral State functions
\r
1909 ==============================================================================
\r
1910 ##### Peripheral State functions #####
\r
1911 ==============================================================================
\r
1913 This subsection permits to get in runtime the status of the peripheral
\r
1914 and the data flow.
\r
1921 * @brief Returns the current SD card's status.
\r
1922 * @param hsd: SD handle
\r
1923 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
\r
1924 * SD Status register)
\r
1925 * @retval SD Card error state
\r
1927 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
\r
1929 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
1930 SDIO_DataInitTypeDef SDIO_DataInitStructure;
\r
1931 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
1932 uint32_t count = 0;
\r
1934 /* Check SD response */
\r
1935 if ((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
1937 errorState = SD_LOCK_UNLOCK_FAILED;
\r
1939 return errorState;
\r
1942 /* Set block size for card if it is not equal to current block size for card */
\r
1943 SDIO_CmdInitStructure.Argument = 64;
\r
1944 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
1945 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
1946 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1947 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
1948 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1950 /* Check for error conditions */
\r
1951 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
1953 if (errorState != SD_OK)
\r
1955 return errorState;
\r
1959 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
1960 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
\r
1961 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1963 /* Check for error conditions */
\r
1964 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
1966 if (errorState != SD_OK)
\r
1968 return errorState;
\r
1971 /* Configure the SD DPSM (Data Path State Machine) */
\r
1972 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
\r
1973 SDIO_DataInitStructure.DataLength = 64;
\r
1974 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
\r
1975 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
1976 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
1977 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
\r
1978 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
\r
1980 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
\r
1981 SDIO_CmdInitStructure.Argument = 0;
\r
1982 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_APP_STAUS;
\r
1983 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
1985 /* Check for error conditions */
\r
1986 errorState = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STAUS);
\r
1988 if (errorState != SD_OK)
\r
1990 return errorState;
\r
1993 /* Get status data */
\r
1994 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
\r
1996 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
1998 for (count = 0; count < 8; count++)
\r
2000 *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
\r
2007 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
2009 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
2011 errorState = SD_DATA_TIMEOUT;
\r
2013 return errorState;
\r
2015 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
2017 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
2019 errorState = SD_DATA_CRC_FAIL;
\r
2021 return errorState;
\r
2023 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
2025 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
2027 errorState = SD_RX_OVERRUN;
\r
2029 return errorState;
\r
2031 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
\r
2033 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
\r
2035 errorState = SD_START_BIT_ERR;
\r
2037 return errorState;
\r
2040 count = SD_DATATIMEOUT;
\r
2041 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
\r
2043 *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
\r
2048 /* Clear all the static status flags*/
\r
2049 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2051 return errorState;
\r
2055 * @brief Gets the current sd card data status.
\r
2056 * @param hsd: SD handle
\r
2057 * @retval Data Transfer state
\r
2059 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
\r
2061 HAL_SD_CardStateTypedef cardstate = SD_CARD_TRANSFER;
\r
2063 /* Get SD card state */
\r
2064 cardstate = SD_GetState(hsd);
\r
2066 /* Find SD status according to card state*/
\r
2067 if (cardstate == SD_CARD_TRANSFER)
\r
2069 return SD_TRANSFER_OK;
\r
2071 else if(cardstate == SD_CARD_ERROR)
\r
2073 return SD_TRANSFER_ERROR;
\r
2077 return SD_TRANSFER_BUSY;
\r
2082 * @brief Gets the SD card status.
\r
2083 * @param hsd: SD handle
\r
2084 * @param pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
\r
2085 * will contain the SD card status information
\r
2086 * @retval SD Card error state
\r
2088 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
\r
2090 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2092 uint32_t SD_STATUS[16];
\r
2094 errorState = HAL_SD_SendSDStatus(hsd, SD_STATUS);
\r
2096 if (errorState != SD_OK)
\r
2098 return errorState;
\r
2102 tmp = (SD_STATUS[0] & 0xC0) >> 6;
\r
2103 pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
\r
2106 tmp = (SD_STATUS[0] & 0x20) >> 5;
\r
2107 pCardStatus->SECURED_MODE = (uint8_t)tmp;
\r
2110 tmp = (SD_STATUS[2] & 0xFF);
\r
2111 pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
\r
2114 tmp = (SD_STATUS[3] & 0xFF);
\r
2115 pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
\r
2118 tmp = (SD_STATUS[4] & 0xFF);
\r
2119 pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
\r
2122 tmp = (SD_STATUS[5] & 0xFF);
\r
2123 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
\r
2126 tmp = (SD_STATUS[6] & 0xFF);
\r
2127 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
\r
2130 tmp = (SD_STATUS[7] & 0xFF);
\r
2131 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
\r
2134 tmp = (SD_STATUS[8] & 0xFF);
\r
2135 pCardStatus->SPEED_CLASS = (uint8_t)tmp;
\r
2138 tmp = (SD_STATUS[9] & 0xFF);
\r
2139 pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
\r
2142 tmp = (SD_STATUS[10] & 0xF0) >> 4;
\r
2143 pCardStatus->AU_SIZE = (uint8_t)tmp;
\r
2146 tmp = (SD_STATUS[11] & 0xFF);
\r
2147 pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
\r
2150 tmp = (SD_STATUS[12] & 0xFF);
\r
2151 pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
\r
2154 tmp = (SD_STATUS[13] & 0xFC) >> 2;
\r
2155 pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
\r
2158 tmp = (SD_STATUS[13] & 0x3);
\r
2159 pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
\r
2161 return errorState;
\r
2169 * @brief SD DMA transfer complete Rx callback.
\r
2170 * @param hdma: DMA handle
\r
2173 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
\r
2175 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
2177 /* DMA transfer is complete */
\r
2178 hsd->DmaTransferCplt = 1;
\r
2180 /* Wait until SD transfer is complete */
\r
2181 while(hsd->SdTransferCplt == 0)
\r
2185 /* Transfer complete user callback */
\r
2186 HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
\r
2190 * @brief SD DMA transfer Error Rx callback.
\r
2191 * @param hdma: DMA handle
\r
2194 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
\r
2196 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
2198 /* Transfer complete user callback */
\r
2199 HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
\r
2203 * @brief SD DMA transfer complete Tx callback.
\r
2204 * @param hdma: DMA handle
\r
2207 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
\r
2209 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
2211 /* DMA transfer is complete */
\r
2212 hsd->DmaTransferCplt = 1;
\r
2214 /* Wait until SD transfer is complete */
\r
2215 while(hsd->SdTransferCplt == 0)
\r
2219 /* Transfer complete user callback */
\r
2220 HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
\r
2224 * @brief SD DMA transfer Error Tx callback.
\r
2225 * @param hdma: DMA handle
\r
2228 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
\r
2230 SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\r
2232 /* Transfer complete user callback */
\r
2233 HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
\r
2237 * @brief Returns the SD current state.
\r
2238 * @param hsd: SD handle
\r
2239 * @retval SD card current state
\r
2241 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
\r
2243 uint32_t resp1 = 0;
\r
2245 if (SD_SendStatus(hsd, &resp1) != SD_OK)
\r
2247 return SD_CARD_ERROR;
\r
2251 return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
\r
2256 * @brief Initializes all cards or single card as the case may be Card(s) come
\r
2257 * into standby state.
\r
2258 * @param hsd: SD handle
\r
2259 * @retval SD Card error state
\r
2261 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
\r
2263 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
2264 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2265 uint16_t sd_rca = 1;
\r
2267 if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
\r
2269 errorState = SD_REQUEST_NOT_APPLICABLE;
\r
2271 return errorState;
\r
2274 if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
\r
2276 /* Send CMD2 ALL_SEND_CID */
\r
2277 SDIO_CmdInitStructure.Argument = 0;
\r
2278 SDIO_CmdInitStructure.CmdIndex = SD_CMD_ALL_SEND_CID;
\r
2279 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_LONG;
\r
2280 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2281 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
2282 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2284 /* Check for error conditions */
\r
2285 errorState = SD_CmdResp2Error(hsd);
\r
2287 if(errorState != SD_OK)
\r
2289 return errorState;
\r
2292 /* Get Card identification number data */
\r
2293 hsd->CID[0] = SDIO_GetResponse(SDIO_RESP1);
\r
2294 hsd->CID[1] = SDIO_GetResponse(SDIO_RESP2);
\r
2295 hsd->CID[2] = SDIO_GetResponse(SDIO_RESP3);
\r
2296 hsd->CID[3] = SDIO_GetResponse(SDIO_RESP4);
\r
2299 if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
2300 (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
2302 /* Send CMD3 SET_REL_ADDR with argument 0 */
\r
2303 /* SD Card publishes its RCA. */
\r
2304 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_REL_ADDR;
\r
2305 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
2306 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2308 /* Check for error conditions */
\r
2309 errorState = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
\r
2311 if(errorState != SD_OK)
\r
2313 return errorState;
\r
2317 if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
\r
2319 /* Get the SD card RCA */
\r
2320 hsd->RCA = sd_rca;
\r
2322 /* Send CMD9 SEND_CSD with argument as card's RCA */
\r
2323 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
2324 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEND_CSD;
\r
2325 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_LONG;
\r
2326 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2328 /* Check for error conditions */
\r
2329 errorState = SD_CmdResp2Error(hsd);
\r
2331 if(errorState != SD_OK)
\r
2333 return errorState;
\r
2336 /* Get Card Specific Data */
\r
2337 hsd->CSD[0] = SDIO_GetResponse(SDIO_RESP1);
\r
2338 hsd->CSD[1] = SDIO_GetResponse(SDIO_RESP2);
\r
2339 hsd->CSD[2] = SDIO_GetResponse(SDIO_RESP3);
\r
2340 hsd->CSD[3] = SDIO_GetResponse(SDIO_RESP4);
\r
2343 /* All cards are initialized */
\r
2344 return errorState;
\r
2348 * @brief Selects od Deselects the corresponding card.
\r
2349 * @param hsd: SD handle
\r
2350 * @param addr: Address of the card to be selected
\r
2351 * @retval SD Card error state
\r
2353 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
\r
2355 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
2356 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2358 /* Send CMD7 SDIO_SEL_DESEL_CARD */
\r
2359 SDIO_CmdInitStructure.Argument = (uint32_t)addr;
\r
2360 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEL_DESEL_CARD;
\r
2361 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
2362 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2363 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
2364 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2366 /* Check for error conditions */
\r
2367 errorState = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
\r
2369 return errorState;
\r
2373 * @brief Enquires cards about their operating voltage and configures clock
\r
2374 * controls and stores SD information that will be needed in future
\r
2375 * in the SD handle.
\r
2376 * @param hsd: SD handle
\r
2377 * @retval SD Card error state
\r
2379 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
\r
2381 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
2382 __IO HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2383 uint32_t response = 0, count = 0, validvoltage = 0;
\r
2384 uint32_t SDType = SD_STD_CAPACITY;
\r
2386 /* Power ON Sequence -------------------------------------------------------*/
\r
2387 /* Disable SDIO Clock */
\r
2388 __HAL_SD_SDIO_DISABLE();
\r
2390 /* Set Power State to ON */
\r
2391 SDIO_PowerState_ON(hsd->Instance);
\r
2393 /* Enable SDIO Clock */
\r
2394 __HAL_SD_SDIO_ENABLE();
\r
2396 /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
\r
2397 /* No CMD response required */
\r
2398 SDIO_CmdInitStructure.Argument = 0;
\r
2399 SDIO_CmdInitStructure.CmdIndex = SD_CMD_GO_IDLE_STATE;
\r
2400 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_NO;
\r
2401 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2402 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
2403 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2405 /* Check for error conditions */
\r
2406 errorState = SD_CmdError(hsd);
\r
2408 if(errorState != SD_OK)
\r
2410 /* CMD Response TimeOut (wait for CMDSENT flag) */
\r
2411 return errorState;
\r
2414 /* CMD8: SEND_IF_COND ------------------------------------------------------*/
\r
2415 /* Send CMD8 to verify SD card interface operating condition */
\r
2416 /* Argument: - [31:12]: Reserved (shall be set to '0')
\r
2417 - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
\r
2418 - [7:0]: Check Pattern (recommended 0xAA) */
\r
2419 /* CMD Response: R7 */
\r
2420 SDIO_CmdInitStructure.Argument = SD_CHECK_PATTERN;
\r
2421 SDIO_CmdInitStructure.CmdIndex = SD_SDIO_SEND_IF_COND;
\r
2422 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
2423 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2425 /* Check for error conditions */
\r
2426 errorState = SD_CmdResp7Error(hsd);
\r
2428 if (errorState == SD_OK)
\r
2431 hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
\r
2432 SDType = SD_HIGH_CAPACITY;
\r
2436 SDIO_CmdInitStructure.Argument = 0;
\r
2437 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
\r
2438 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2440 /* Check for error conditions */
\r
2441 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
2443 /* If errorState is Command TimeOut, it is a MMC card */
\r
2444 /* If errorState is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
\r
2446 if(errorState == SD_OK)
\r
2449 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
\r
2450 while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
\r
2453 /* SEND CMD55 APP_CMD with RCA as 0 */
\r
2454 SDIO_CmdInitStructure.Argument = 0;
\r
2455 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
\r
2456 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
2457 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2458 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
2459 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2461 /* Check for error conditions */
\r
2462 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
2464 if(errorState != SD_OK)
\r
2466 return errorState;
\r
2470 SDIO_CmdInitStructure.Argument = SD_VOLTAGE_WINDOW_SD | SDType;
\r
2471 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_APP_OP_COND;
\r
2472 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
2473 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2474 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
2475 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2477 /* Check for error conditions */
\r
2478 errorState = SD_CmdResp3Error(hsd);
\r
2480 if(errorState != SD_OK)
\r
2482 return errorState;
\r
2485 /* Get command response */
\r
2486 response = SDIO_GetResponse(SDIO_RESP1);
\r
2488 /* Get operating voltage*/
\r
2489 validvoltage = (((response >> 31) == 1) ? 1 : 0);
\r
2494 if(count >= SD_MAX_VOLT_TRIAL)
\r
2496 errorState = SD_INVALID_VOLTRANGE;
\r
2498 return errorState;
\r
2501 if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
\r
2503 hsd->CardType = HIGH_CAPACITY_SD_CARD;
\r
2506 } /* else MMC Card */
\r
2508 return errorState;
\r
2512 * @brief Turns the SDIO output signals off.
\r
2513 * @param hsd: SD handle
\r
2514 * @retval SD Card error state
\r
2516 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
\r
2518 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2520 /* Set Power State to OFF */
\r
2521 SDIO_PowerState_OFF(hsd->Instance);
\r
2523 return errorState;
\r
2527 * @brief Returns the current card's status.
\r
2528 * @param hsd: SD handle
\r
2529 * @param pCardStatus: pointer to the buffer that will contain the SD card
\r
2530 * status (Card Status register)
\r
2531 * @retval SD Card error state
\r
2533 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
\r
2535 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
2536 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2538 if(pCardStatus == NULL)
\r
2540 errorState = SD_INVALID_PARAMETER;
\r
2542 return errorState;
\r
2545 /* Send Status command */
\r
2546 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
2547 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEND_STATUS;
\r
2548 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
2549 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2550 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
2551 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2553 /* Check for error conditions */
\r
2554 errorState = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
\r
2556 if(errorState != SD_OK)
\r
2558 return errorState;
\r
2561 /* Get SD card status */
\r
2562 *pCardStatus = SDIO_GetResponse(SDIO_RESP1);
\r
2564 return errorState;
\r
2568 * @brief Checks for error conditions for CMD0.
\r
2569 * @param hsd: SD handle
\r
2570 * @retval SD Card error state
\r
2572 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
\r
2574 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2575 uint32_t timeout, tmp;
\r
2577 timeout = SDIO_CMD0TIMEOUT;
\r
2579 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
\r
2581 while((timeout > 0) && (!tmp))
\r
2583 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
\r
2589 errorState = SD_CMD_RSP_TIMEOUT;
\r
2590 return errorState;
\r
2593 /* Clear all the static flags */
\r
2594 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2596 return errorState;
\r
2600 * @brief Checks for error conditions for R7 response.
\r
2601 * @param hsd: SD handle
\r
2602 * @retval SD Card error state
\r
2604 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
\r
2606 HAL_SD_ErrorTypedef errorState = SD_ERROR;
\r
2607 uint32_t timeout = SDIO_CMD0TIMEOUT, tmp;
\r
2609 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
\r
2611 while((!tmp) && (timeout > 0))
\r
2613 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
\r
2617 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2619 if((timeout == 0) || tmp)
\r
2621 /* Card is not V2.0 compliant or card does not support the set voltage range */
\r
2622 errorState = SD_CMD_RSP_TIMEOUT;
\r
2624 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2626 return errorState;
\r
2629 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
\r
2631 /* Card is SD V2.0 compliant */
\r
2632 errorState = SD_OK;
\r
2634 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
\r
2636 return errorState;
\r
2639 return errorState;
\r
2643 * @brief Checks for error conditions for R1 response.
\r
2644 * @param hsd: SD handle
\r
2645 * @param SD_CMD: The sent command index
\r
2646 * @retval SD Card error state
\r
2648 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
\r
2650 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2651 uint32_t response_R1;
\r
2653 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
2657 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
2659 errorState = SD_CMD_RSP_TIMEOUT;
\r
2661 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2663 return errorState;
\r
2665 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
2667 errorState = SD_CMD_CRC_FAIL;
\r
2669 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
2671 return errorState;
\r
2674 /* Check response received is of desired command */
\r
2675 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
\r
2677 errorState = SD_ILLEGAL_CMD;
\r
2679 return errorState;
\r
2682 /* Clear all the static flags */
\r
2683 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2685 /* We have received response, retrieve it for analysis */
\r
2686 response_R1 = SDIO_GetResponse(SDIO_RESP1);
\r
2688 if((response_R1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
\r
2690 return errorState;
\r
2693 if((response_R1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
\r
2695 return(SD_ADDR_OUT_OF_RANGE);
\r
2698 if((response_R1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
\r
2700 return(SD_ADDR_MISALIGNED);
\r
2703 if((response_R1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
\r
2705 return(SD_BLOCK_LEN_ERR);
\r
2708 if((response_R1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
\r
2710 return(SD_ERASE_SEQ_ERR);
\r
2713 if((response_R1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
\r
2715 return(SD_BAD_ERASE_PARAM);
\r
2718 if((response_R1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
\r
2720 return(SD_WRITE_PROT_VIOLATION);
\r
2723 if((response_R1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
\r
2725 return(SD_LOCK_UNLOCK_FAILED);
\r
2728 if((response_R1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
\r
2730 return(SD_COM_CRC_FAILED);
\r
2733 if((response_R1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
\r
2735 return(SD_ILLEGAL_CMD);
\r
2738 if((response_R1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
\r
2740 return(SD_CARD_ECC_FAILED);
\r
2743 if((response_R1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
\r
2745 return(SD_CC_ERROR);
\r
2748 if((response_R1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
\r
2750 return(SD_GENERAL_UNKNOWN_ERROR);
\r
2753 if((response_R1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
\r
2755 return(SD_STREAM_READ_UNDERRUN);
\r
2758 if((response_R1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
\r
2760 return(SD_STREAM_WRITE_OVERRUN);
\r
2763 if((response_R1 & SD_OCR_CID_CSD_OVERWRIETE) == SD_OCR_CID_CSD_OVERWRIETE)
\r
2765 return(SD_CID_CSD_OVERWRITE);
\r
2768 if((response_R1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
\r
2770 return(SD_WP_ERASE_SKIP);
\r
2773 if((response_R1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
\r
2775 return(SD_CARD_ECC_DISABLED);
\r
2778 if((response_R1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
\r
2780 return(SD_ERASE_RESET);
\r
2783 if((response_R1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
\r
2785 return(SD_AKE_SEQ_ERROR);
\r
2788 return errorState;
\r
2792 * @brief Checks for error conditions for R3 (OCR) response.
\r
2793 * @param hsd: SD handle
\r
2794 * @retval SD Card error state
\r
2796 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
\r
2798 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2800 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
2804 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
2806 errorState = SD_CMD_RSP_TIMEOUT;
\r
2808 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2810 return errorState;
\r
2813 /* Clear all the static flags */
\r
2814 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2816 return errorState;
\r
2820 * @brief Checks for error conditions for R2 (CID or CSD) response.
\r
2821 * @param hsd: SD handle
\r
2822 * @retval SD Card error state
\r
2824 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
\r
2826 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2828 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
2832 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
2834 errorState = SD_CMD_RSP_TIMEOUT;
\r
2836 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2838 return errorState;
\r
2840 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
2842 errorState = SD_CMD_CRC_FAIL;
\r
2844 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
2846 return errorState;
\r
2849 /* Clear all the static flags */
\r
2850 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2852 return errorState;
\r
2856 * @brief Checks for error conditions for R6 (RCA) response.
\r
2857 * @param hsd: SD handle
\r
2858 * @param SD_CMD: The sent command index
\r
2859 * @param pRCA: Pointer to the variable that will contain the SD card relative
\r
2861 * @retval SD Card error state
\r
2863 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
\r
2865 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2866 uint32_t response_R1;
\r
2868 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
2872 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
2874 errorState = SD_CMD_RSP_TIMEOUT;
\r
2876 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2878 return errorState;
\r
2880 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
2882 errorState = SD_CMD_CRC_FAIL;
\r
2884 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
2886 return errorState;
\r
2889 /* Check response received is of desired command */
\r
2890 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
\r
2892 errorState = SD_ILLEGAL_CMD;
\r
2894 return errorState;
\r
2897 /* Clear all the static flags */
\r
2898 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2900 /* We have received response, retrieve it. */
\r
2901 response_R1 = SDIO_GetResponse(SDIO_RESP1);
\r
2903 if((response_R1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
\r
2905 *pRCA = (uint16_t) (response_R1 >> 16);
\r
2907 return errorState;
\r
2910 if((response_R1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
\r
2912 return(SD_GENERAL_UNKNOWN_ERROR);
\r
2915 if((response_R1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
\r
2917 return(SD_ILLEGAL_CMD);
\r
2920 if((response_R1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
\r
2922 return(SD_COM_CRC_FAILED);
\r
2925 return errorState;
\r
2929 * @brief Enables the SDIO wide bus mode.
\r
2930 * @param hsd: SD handle
\r
2931 * @retval SD Card error state
\r
2933 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
\r
2935 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
2936 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
2938 uint32_t scr[2] = {0, 0};
\r
2940 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
2942 errorState = SD_LOCK_UNLOCK_FAILED;
\r
2944 return errorState;
\r
2947 /* Get SCR Register */
\r
2948 errorState = SD_FindSCR(hsd, scr);
\r
2950 if(errorState != SD_OK)
\r
2952 return errorState;
\r
2955 /* If requested card supports wide bus operation */
\r
2956 if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
\r
2958 /* Send CMD55 APP_CMD with argument as card's RCA.*/
\r
2959 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
2960 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
\r
2961 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
2962 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2963 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
2964 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2966 /* Check for error conditions */
\r
2967 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
2969 if(errorState != SD_OK)
\r
2971 return errorState;
\r
2974 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
\r
2975 SDIO_CmdInitStructure.Argument = 2;
\r
2976 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
\r
2977 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
2979 /* Check for error conditions */
\r
2980 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
\r
2982 if(errorState != SD_OK)
\r
2984 return errorState;
\r
2987 return errorState;
\r
2991 errorState = SD_REQUEST_NOT_APPLICABLE;
\r
2993 return errorState;
\r
2998 * @brief Disables the SDIO wide bus mode.
\r
2999 * @param hsd: SD handle
\r
3000 * @retval SD Card error state
\r
3002 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd)
\r
3004 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
3005 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
3007 uint32_t scr[2] = {0, 0};
\r
3009 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
3011 errorState = SD_LOCK_UNLOCK_FAILED;
\r
3013 return errorState;
\r
3016 /* Get SCR Register */
\r
3017 errorState = SD_FindSCR(hsd, scr);
\r
3019 if(errorState != SD_OK)
\r
3021 return errorState;
\r
3024 /* If requested card supports 1 bit mode operation */
\r
3025 if((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
\r
3027 /* Send CMD55 APP_CMD with argument as card's RCA */
\r
3028 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
3029 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
\r
3030 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
3031 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
3032 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
3033 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
3035 /* Check for error conditions */
\r
3036 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
3038 if(errorState != SD_OK)
\r
3040 return errorState;
\r
3043 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
\r
3044 SDIO_CmdInitStructure.Argument = 0;
\r
3045 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
\r
3046 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
3048 /* Check for error conditions */
\r
3049 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
\r
3051 if(errorState != SD_OK)
\r
3053 return errorState;
\r
3056 return errorState;
\r
3060 errorState = SD_REQUEST_NOT_APPLICABLE;
\r
3062 return errorState;
\r
3068 * @brief Finds the SD card SCR register value.
\r
3069 * @param hsd: SD handle
\r
3070 * @param pSCR: pointer to the buffer that will contain the SCR value
\r
3071 * @retval SD Card error state
\r
3073 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
\r
3075 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
3076 SDIO_DataInitTypeDef SDIO_DataInitStructure;
\r
3077 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
3078 uint32_t index = 0;
\r
3079 uint32_t tempscr[2] = {0, 0};
\r
3081 /* Set Block Size To 8 Bytes */
\r
3082 /* Send CMD55 APP_CMD with argument as card's RCA */
\r
3083 SDIO_CmdInitStructure.Argument = (uint32_t)8;
\r
3084 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
3085 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
3086 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
3087 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
3088 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
3090 /* Check for error conditions */
\r
3091 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
3093 if(errorState != SD_OK)
\r
3095 return errorState;
\r
3098 /* Send CMD55 APP_CMD with argument as card's RCA */
\r
3099 SDIO_CmdInitStructure.Argument = (uint32_t)((hsd->RCA) << 16);
\r
3100 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
\r
3101 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
3103 /* Check for error conditions */
\r
3104 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
3106 if(errorState != SD_OK)
\r
3108 return errorState;
\r
3110 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
\r
3111 SDIO_DataInitStructure.DataLength = 8;
\r
3112 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
\r
3113 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
3114 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
3115 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
\r
3116 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
\r
3118 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
\r
3119 SDIO_CmdInitStructure.Argument = 0;
\r
3120 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_APP_SEND_SCR;
\r
3121 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
3123 /* Check for error conditions */
\r
3124 errorState = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_SEND_SCR);
\r
3126 if(errorState != SD_OK)
\r
3128 return errorState;
\r
3131 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
\r
3133 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
\r
3135 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
\r
3140 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
3142 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
3144 errorState = SD_DATA_TIMEOUT;
\r
3146 return errorState;
\r
3148 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
3150 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
3152 errorState = SD_DATA_CRC_FAIL;
\r
3154 return errorState;
\r
3156 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
3158 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
3160 errorState = SD_RX_OVERRUN;
\r
3162 return errorState;
\r
3164 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
\r
3166 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
\r
3168 errorState = SD_START_BIT_ERR;
\r
3170 return errorState;
\r
3173 /* Clear all the static flags */
\r
3174 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
3176 *(pSCR + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) |\
\r
3177 ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
\r
3179 *(pSCR) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) |\
\r
3180 ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
\r
3182 return errorState;
\r
3186 * @brief Checks if the SD card is in programming state.
\r
3187 * @param hsd: SD handle
\r
3188 * @param pStatus: pointer to the variable that will contain the SD card state
\r
3189 * @retval SD Card error state
\r
3191 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus)
\r
3193 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
\r
3194 HAL_SD_ErrorTypedef errorState = SD_OK;
\r
3195 __IO uint32_t responseR1 = 0;
\r
3197 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
3198 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEND_STATUS;
\r
3199 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
\r
3200 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
3201 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
\r
3202 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
\r
3204 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
3208 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
3210 errorState = SD_CMD_RSP_TIMEOUT;
\r
3212 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
3214 return errorState;
\r
3216 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
3218 errorState = SD_CMD_CRC_FAIL;
\r
3220 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
3222 return errorState;
\r
3225 /* Check response received is of desired command */
\r
3226 if((uint32_t)SDIO_GetCommandResponse(hsd->Instance) != SD_CMD_SEND_STATUS)
\r
3228 errorState = SD_ILLEGAL_CMD;
\r
3230 return errorState;
\r
3233 /* Clear all the static flags */
\r
3234 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
3237 /* We have received response, retrieve it for analysis */
\r
3238 responseR1 = SDIO_GetResponse(SDIO_RESP1);
\r
3240 /* Find out card status */
\r
3241 *pStatus = (uint8_t)((responseR1 >> 9) & 0x0000000F);
\r
3243 if((responseR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
\r
3245 return errorState;
\r
3248 if((responseR1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
\r
3250 return(SD_ADDR_OUT_OF_RANGE);
\r
3253 if((responseR1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
\r
3255 return(SD_ADDR_MISALIGNED);
\r
3258 if((responseR1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
\r
3260 return(SD_BLOCK_LEN_ERR);
\r
3263 if((responseR1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
\r
3265 return(SD_ERASE_SEQ_ERR);
\r
3268 if((responseR1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
\r
3270 return(SD_BAD_ERASE_PARAM);
\r
3273 if((responseR1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
\r
3275 return(SD_WRITE_PROT_VIOLATION);
\r
3278 if((responseR1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
\r
3280 return(SD_LOCK_UNLOCK_FAILED);
\r
3283 if((responseR1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
\r
3285 return(SD_COM_CRC_FAILED);
\r
3288 if((responseR1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
\r
3290 return(SD_ILLEGAL_CMD);
\r
3293 if((responseR1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
\r
3295 return(SD_CARD_ECC_FAILED);
\r
3298 if((responseR1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
\r
3300 return(SD_CC_ERROR);
\r
3303 if((responseR1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
\r
3305 return(SD_GENERAL_UNKNOWN_ERROR);
\r
3308 if((responseR1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
\r
3310 return(SD_STREAM_READ_UNDERRUN);
\r
3313 if((responseR1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
\r
3315 return(SD_STREAM_WRITE_OVERRUN);
\r
3318 if((responseR1 & SD_OCR_CID_CSD_OVERWRIETE) == SD_OCR_CID_CSD_OVERWRIETE)
\r
3320 return(SD_CID_CSD_OVERWRITE);
\r
3323 if((responseR1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
\r
3325 return(SD_WP_ERASE_SKIP);
\r
3328 if((responseR1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
\r
3330 return(SD_CARD_ECC_DISABLED);
\r
3333 if((responseR1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
\r
3335 return(SD_ERASE_RESET);
\r
3338 if((responseR1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
\r
3340 return(SD_AKE_SEQ_ERROR);
\r
3343 return errorState;
\r
3350 #endif /* HAL_SD_MODULE_ENABLED */
\r
3359 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
\r