2 ******************************************************************************
\r
3 * @file stm32f7xx_hal_sd.c
\r
4 * @author MCD Application Team
\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 (SDMMC 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 SDMMC memories which uses the HAL
\r
29 SDMMC driver functions to interface with SD and uSD cards devices.
\r
30 It is used as follows:
\r
32 (#)Initialize the SDMMC low level resources by implement the HAL_SD_MspInit() API:
\r
33 (##) Enable the SDMMC interface clock using __HAL_RCC_SDMMC_CLK_ENABLE();
\r
34 (##) SDMMC pins configuration for SD card
\r
35 (+++) Enable the clock for the SDMMC GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
\r
36 (+++) Configure these SDMMC 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 __HAL_RCC_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 SDMMC and DMA interrupt priorities using functions
\r
44 HAL_NVIC_SetPriority(); DMA priority is superior to SDMMC's priority
\r
45 (+++) Enable the NVIC DMA and SDMMC IRQs using function HAL_NVIC_EnableIRQ()
\r
46 (+++) SDMMC interrupts are managed using the macros __HAL_SD_SDMMC_ENABLE_IT()
\r
47 and __HAL_SD_SDMMC_DISABLE_IT() inside the communication process.
\r
48 (+++) SDMMC interrupts pending bits are managed using the macros __HAL_SD_SDMMC_GET_IT()
\r
49 and __HAL_SD_SDMMC_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 (SDMMC_CK) is computed as follows:
\r
65 SDMMC_CK = SDMMCCLK / (ClockDiv + 2)
\r
67 In initialization mode and according to the SD Card standard,
\r
68 make sure that the SDMMC_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 In transfer mode and according to the SD Card standard, make sure that the
\r
80 SDMMC_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
\r
81 To be able to use a frequency higher than 24MHz, you should use the SDMMC
\r
82 peripheral in bypass mode. Refer to the corresponding reference manual
\r
85 (#) Select the corresponding SD Card according to the address read with the step 2.
\r
87 (#) Configure the SD Card in wide bus mode: 4-bits data.
\r
89 *** SD Card Read operation ***
\r
90 ==============================
\r
92 (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
\r
93 This function support only 512-bytes block length (the block size should be
\r
94 chosen as 512 bytes).
\r
95 You can choose either one block read operation or multiple block read operation
\r
96 by adjusting the "NumberOfBlocks" parameter.
\r
98 (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
\r
99 This function support only 512-bytes block length (the block size should be
\r
100 chosen as 512 bytes).
\r
101 You can choose either one block read operation or multiple block read operation
\r
102 by adjusting the "NumberOfBlocks" parameter.
\r
103 After this, you have to call the function HAL_SD_CheckReadOperation(), to insure
\r
104 that the read transfer is done correctly in both DMA and SD sides.
\r
106 *** SD Card Write operation ***
\r
107 ===============================
\r
109 (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
\r
110 This function support only 512-bytes block length (the block size should be
\r
111 chosen as 512 bytes).
\r
112 You can choose either one block read operation or multiple block read operation
\r
113 by adjusting the "NumberOfBlocks" parameter.
\r
115 (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
\r
116 This function support only 512-bytes block length (the block size should be
\r
117 chosen as 512 byte).
\r
118 You can choose either one block read operation or multiple block read operation
\r
119 by adjusting the "NumberOfBlocks" parameter.
\r
120 After this, you have to call the function HAL_SD_CheckWriteOperation(), to insure
\r
121 that the write transfer is done correctly in both DMA and SD sides.
\r
123 *** SD card status ***
\r
124 ======================
\r
126 (+) At any time, you can check the SD Card status and get the SD card state
\r
127 by using the HAL_SD_GetStatus() function. This function checks first if the
\r
128 SD card is still connected and then get the internal SD Card transfer state.
\r
129 (+) You can also get the SD card SD Status register by using the HAL_SD_SendSDStatus()
\r
132 *** SD HAL driver macros list ***
\r
133 ==================================
\r
135 Below the list of most used macros in SD HAL driver.
\r
137 (+) __HAL_SD_SDMMC_ENABLE : Enable the SD device
\r
138 (+) __HAL_SD_SDMMC_DISABLE : Disable the SD device
\r
139 (+) __HAL_SD_SDMMC_DMA_ENABLE: Enable the SDMMC DMA transfer
\r
140 (+) __HAL_SD_SDMMC_DMA_DISABLE: Disable the SDMMC DMA transfer
\r
141 (+) __HAL_SD_SDMMC_ENABLE_IT: Enable the SD device interrupt
\r
142 (+) __HAL_SD_SDMMC_DISABLE_IT: Disable the SD device interrupt
\r
143 (+) __HAL_SD_SDMMC_GET_FLAG:Check whether the specified SD flag is set or not
\r
144 (+) __HAL_SD_SDMMC_CLEAR_FLAG: Clear the SD's pending flags
\r
146 (@) You can refer to the SD HAL driver header file for more useful macros
\r
149 ******************************************************************************
\r
152 * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
\r
154 * Redistribution and use in source and binary forms, with or without modification,
\r
155 * are permitted provided that the following conditions are met:
\r
156 * 1. Redistributions of source code must retain the above copyright notice,
\r
157 * this list of conditions and the following disclaimer.
\r
158 * 2. Redistributions in binary form must reproduce the above copyright notice,
\r
159 * this list of conditions and the following disclaimer in the documentation
\r
160 * and/or other materials provided with the distribution.
\r
161 * 3. Neither the name of STMicroelectronics nor the names of its contributors
\r
162 * may be used to endorse or promote products derived from this software
\r
163 * without specific prior written permission.
\r
165 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
\r
166 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
\r
167 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
\r
168 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
\r
169 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
\r
170 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
\r
171 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
\r
172 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
\r
173 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
\r
174 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
176 ******************************************************************************
\r
179 #include "FreeRTOS.h"
\r
182 /* This include is not necessary except for including the definition of FF_PRINTF(). */
\r
183 #include "ff_headers.h"
\r
185 /* Includes ------------------------------------------------------------------*/
\r
186 #include "stm32f7xx_hal.h"
\r
188 #ifdef HAL_SD_MODULE_ENABLED
\r
190 /** @addtogroup STM32F7xx_HAL_Driver
\r
198 /* Private typedef -----------------------------------------------------------*/
\r
199 /* Private define ------------------------------------------------------------*/
\r
200 /** @addtogroup SD_Private_Defines
\r
204 * @brief SDMMC Data block size
\r
206 #define DATA_BLOCK_SIZE ((uint32_t)(9 << 4))
\r
208 * @brief SDMMC Static flags, Timeout, FIFO Address
\r
210 #define SDMMC_STATIC_FLAGS ((uint32_t)(SDIO_FLAG_CCRCFAIL | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_CTIMEOUT |\
\r
211 SDIO_FLAG_DTIMEOUT | SDIO_FLAG_TXUNDERR | SDIO_FLAG_RXOVERR |\
\r
212 SDIO_FLAG_CMDREND | SDIO_FLAG_CMDSENT | SDIO_FLAG_DATAEND |\
\r
213 SDIO_FLAG_DBCKEND))
\r
215 #define SDMMC_CMD0TIMEOUT ((uint32_t)0x00010000)
\r
218 * @brief Mask for errors Card Status R1 (OCR Register)
\r
220 #define SD_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000)
\r
221 #define SD_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000)
\r
222 #define SD_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000)
\r
223 #define SD_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000)
\r
224 #define SD_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000)
\r
225 #define SD_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000)
\r
226 #define SD_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000)
\r
227 #define SD_OCR_COM_CRC_FAILED ((uint32_t)0x00800000)
\r
228 #define SD_OCR_ILLEGAL_CMD ((uint32_t)0x00400000)
\r
229 #define SD_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000)
\r
230 #define SD_OCR_CC_ERROR ((uint32_t)0x00100000)
\r
231 #define SD_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000)
\r
232 #define SD_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000)
\r
233 #define SD_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000)
\r
234 #define SD_OCR_CID_CSD_OVERWRITE ((uint32_t)0x00010000)
\r
235 #define SD_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000)
\r
236 #define SD_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000)
\r
237 #define SD_OCR_ERASE_RESET ((uint32_t)0x00002000)
\r
238 #define SD_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008)
\r
239 #define SD_OCR_ERRORBITS ((uint32_t)0xFDFFE008)
\r
242 * @brief Masks for R6 Response
\r
244 #define SD_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000)
\r
245 #define SD_R6_ILLEGAL_CMD ((uint32_t)0x00004000)
\r
246 #define SD_R6_COM_CRC_FAILED ((uint32_t)0x00008000)
\r
248 #define SD_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000)
\r
249 #define SD_HIGH_CAPACITY ((uint32_t)0x40000000)
\r
250 #define SD_STD_CAPACITY ((uint32_t)0x00000000)
\r
251 #define SD_CHECK_PATTERN ((uint32_t)0x000001AA)
\r
253 #define SD_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFF)
\r
254 #define SD_ALLZERO ((uint32_t)0x00000000)
\r
256 #define SD_WIDE_BUS_SUPPORT ((uint32_t)0x00040000)
\r
257 #define SD_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000)
\r
258 #define SD_CARD_LOCKED ((uint32_t)0x02000000)
\r
260 #define SD_DATATIMEOUT ((uint32_t)0xFFFFFFFF)
\r
261 #define SD_0TO7BITS ((uint32_t)0x000000FF)
\r
262 #define SD_8TO15BITS ((uint32_t)0x0000FF00)
\r
263 #define SD_16TO23BITS ((uint32_t)0x00FF0000)
\r
264 #define SD_24TO31BITS ((uint32_t)0xFF000000)
\r
265 #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFF)
\r
267 #define SD_HALFFIFO ((uint32_t)0x00000008)
\r
268 #define SD_HALFFIFOBYTES ((uint32_t)0x00000020)
\r
271 * @brief Command Class Supported
\r
273 #define SD_CCCC_LOCK_UNLOCK ((uint32_t)0x00000080)
\r
274 #define SD_CCCC_WRITE_PROT ((uint32_t)0x00000040)
\r
275 #define SD_CCCC_ERASE ((uint32_t)0x00000020)
\r
278 * @brief Following commands are SD Card Specific commands.
\r
279 * SDMMC_APP_CMD should be sent before sending these commands.
\r
281 #define SD_SDMMC_SEND_IF_COND ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
\r
286 /* Private macro -------------------------------------------------------------*/
\r
288 /* A few macro's that will allow to use the 'SDIO_' macro's that were
\r
289 used in the earlier SDIO drivers. It makes it easier to compare the
\r
292 #define SDIO_FLAG_CCRCFAIL SDMMC_FLAG_CCRCFAIL
\r
293 #define SDIO_FLAG_DCRCFAIL SDMMC_FLAG_DCRCFAIL
\r
294 #define SDIO_FLAG_CTIMEOUT SDMMC_FLAG_CTIMEOUT
\r
295 #define SDIO_FLAG_DTIMEOUT SDMMC_FLAG_DTIMEOUT
\r
296 #define SDIO_FLAG_TXUNDERR SDMMC_FLAG_TXUNDERR
\r
297 #define SDIO_FLAG_RXOVERR SDMMC_FLAG_RXOVERR
\r
298 #define SDIO_FLAG_CMDREND SDMMC_FLAG_CMDREND
\r
299 #define SDIO_FLAG_CMDSENT SDMMC_FLAG_CMDSENT
\r
300 #define SDIO_FLAG_DATAEND SDMMC_FLAG_DATAEND
\r
301 #define SDIO_FLAG_DBCKEND SDMMC_FLAG_DBCKEND
\r
302 #define SDIO_FLAG_RXDAVL SDMMC_FLAG_RXDAVL
\r
303 #define SDIO_FLAG_RXFIFOHF SDMMC_FLAG_RXFIFOHF
\r
304 #define SDIO_FLAG_RXACT SDMMC_FLAG_RXACT
\r
305 #define SDIO_FLAG_TXACT SDMMC_FLAG_TXACT
\r
306 #define SDIO_FLAG_TXFIFOHE SDMMC_FLAG_TXFIFOHE
\r
307 #define SDIO_FLAG_TXFIFOE SDMMC_FLAG_TXFIFOE
\r
309 #define SDIO_CmdInitTypeDef SDMMC_CmdInitTypeDef
\r
310 #define SDIO_DataInitTypeDef SDMMC_DataInitTypeDef
\r
311 #define SDIO_InitTypeDef SDMMC_InitTypeDef
\r
314 #define SDIO_BUS_WIDE_1B SDMMC_BUS_WIDE_1B
\r
315 #define SDIO_BUS_WIDE_4B SDMMC_BUS_WIDE_4B
\r
316 #define SDIO_BUS_WIDE_8B SDMMC_BUS_WIDE_8B
\r
317 #define SDIO_CLOCK_BYPASS_DISABLE SDMMC_CLOCK_BYPASS_DISABLE
\r
318 #define SDIO_CLOCK_EDGE_RISING SDMMC_CLOCK_EDGE_RISING
\r
319 #define SDIO_CLOCK_POWER_SAVE_DISABLE SDMMC_CLOCK_POWER_SAVE_DISABLE
\r
320 #define SDIO_CPSM_ENABLE SDMMC_CPSM_ENABLE
\r
321 #define SDIO_DATABLOCK_SIZE_512B SDMMC_DATABLOCK_SIZE_512B
\r
322 #define SDIO_DATABLOCK_SIZE_64B SDMMC_DATABLOCK_SIZE_64B
\r
323 #define SDIO_DATABLOCK_SIZE_8B SDMMC_DATABLOCK_SIZE_8B
\r
324 #define SDIO_DCTRL_DTEN SDMMC_DCTRL_DTEN
\r
325 #define SDIO_DPSM_ENABLE SDMMC_DPSM_ENABLE
\r
326 #define SDIO_HARDWARE_FLOW_CONTROL_DISABLE SDMMC_HARDWARE_FLOW_CONTROL_DISABLE
\r
327 #define SDIO_HARDWARE_FLOW_CONTROL_ENABLE SDMMC_HARDWARE_FLOW_CONTROL_ENABLE
\r
328 #define SDIO_INIT_CLK_DIV SDMMC_INIT_CLK_DIV
\r
329 #define SDIO_IT_DATAEND SDMMC_IT_DATAEND
\r
330 #define SDIO_IT_DCRCFAIL SDMMC_IT_DCRCFAIL
\r
331 #define SDIO_IT_DTIMEOUT SDMMC_IT_DTIMEOUT
\r
332 #define SDIO_IT_RXFIFOHF SDMMC_IT_RXFIFOHF
\r
333 #define SDIO_IT_RXOVERR SDMMC_IT_RXOVERR
\r
334 #define SDIO_IT_RXOVERR SDMMC_IT_RXOVERR
\r
335 #define SDIO_IT_TXFIFOHE SDMMC_IT_TXFIFOHE
\r
336 #define SDIO_IT_TXUNDERR SDMMC_IT_TXUNDERR
\r
337 #define SDIO_RESP1 SDMMC_RESP1
\r
338 #define SDIO_RESP2 SDMMC_RESP2
\r
339 #define SDIO_RESP3 SDMMC_RESP3
\r
340 #define SDIO_RESP4 SDMMC_RESP4
\r
341 #define SDIO_RESPONSE_LONG SDMMC_RESPONSE_LONG
\r
342 #define SDIO_RESPONSE_NO SDMMC_RESPONSE_NO
\r
343 #define SDIO_RESPONSE_SHORT SDMMC_RESPONSE_SHORT
\r
344 #define SDIO_TRANSFER_DIR_TO_CARD SDMMC_TRANSFER_DIR_TO_CARD
\r
345 #define SDIO_TRANSFER_DIR_TO_SDIO SDMMC_TRANSFER_DIR_TO_SDMMC
\r
346 #define SDIO_TRANSFER_MODE_BLOCK SDMMC_TRANSFER_MODE_BLOCK
\r
347 #define SDIO_WAIT_NO SDMMC_WAIT_NO
\r
349 #ifdef __HAL_SD_SDIO_CLEAR_FLAG
\r
350 #undef __HAL_SD_SDIO_CLEAR_FLAG
\r
353 #ifdef __HAL_SD_SDIO_GET_FLAG
\r
354 #undef __HAL_SD_SDIO_GET_FLAG
\r
357 #ifdef SDIO_ReadFIFO
\r
358 #undef SDIO_ReadFIFO
\r
361 #define __HAL_SD_SDIO_CLEAR_FLAG __HAL_SD_SDMMC_CLEAR_FLAG
\r
362 #define __HAL_SD_SDIO_GET_FLAG __HAL_SD_SDMMC_GET_FLAG
\r
363 #define SDIO_ReadFIFO SDMMC_ReadFIFO
\r
364 #define SDIO_SendCommand SDMMC_SendCommand
\r
365 #define SDIO_Init SDMMC_Init
\r
366 #define SDIO_GetResponse SDMMC_GetResponse
\r
367 #define SDIO_DataConfig SDMMC_DataConfig
\r
368 #define SDIO_GetPowerState SDMMC_GetPowerState
\r
369 #define SDIO_PowerState_ON SDMMC_PowerState_ON
\r
370 #define SDIO_PowerState_OFF SDMMC_PowerState_OFF
\r
371 #define SDIO_GetCommandResponse SDMMC_GetCommandResponse
\r
373 #define SDIO_STATIC_FLAGS SDMMC_STATIC_FLAGS
\r
375 /* Private variables ---------------------------------------------------------*/
\r
376 /* Private function prototypes -----------------------------------------------*/
\r
377 /* Private functions ---------------------------------------------------------*/
\r
378 /** @defgroup SD_Private_Functions SD Private Functions
\r
381 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
\r
382 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
\r
383 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd);
\r
384 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
\r
385 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
\r
386 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
\r
387 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
\r
388 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
\r
389 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
\r
390 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
\r
391 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
\r
392 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
\r
393 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
\r
394 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
\r
395 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
\r
396 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
\r
397 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
\r
398 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
\r
399 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
\r
400 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
\r
404 /* Exported functions --------------------------------------------------------*/
\r
405 /** @addtogroup SD_Exported_Functions
\r
409 /** @addtogroup SD_Exported_Functions_Group1
\r
410 * @brief Initialization and de-initialization functions
\r
413 ==============================================================================
\r
414 ##### Initialization and de-initialization functions #####
\r
415 ==============================================================================
\r
417 This section provides functions allowing to initialize/de-initialize the SD
\r
418 card device to be ready for use.
\r
426 * @brief Initializes the SD card according to the specified parameters in the
\r
427 SD_HandleTypeDef and create the associated handle.
\r
428 * @param hsd: SD handle
\r
429 * @param SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information
\r
430 * @retval HAL SD error state
\r
432 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
\r
434 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
435 SD_InitTypeDef tmpinit;
\r
437 /* Allocate lock resource and initialize it */
\r
438 hsd->Lock = HAL_UNLOCKED;
\r
440 /* Initialize the low level hardware (MSP) */
\r
441 HAL_SD_MspInit(hsd);
\r
443 /* Default SDMMC peripheral configuration for SD card initialization */
\r
444 tmpinit.ClockEdge = SDIO_CLOCK_EDGE_RISING;
\r
445 tmpinit.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
\r
446 tmpinit.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
\r
447 #if( BUS_4BITS != 0 )
\r
450 tmpinit.BusWide = SDIO_BUS_WIDE_4B;
\r
455 tmpinit.BusWide = SDIO_BUS_WIDE_1B;
\r
458 tmpinit.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
\r
459 tmpinit.ClockDiv = SDIO_INIT_CLK_DIV;
\r
461 /* Initialize SDMMC peripheral interface with default configuration */
\r
462 SDIO_Init(hsd->Instance, tmpinit);
\r
464 /* Identify card operating voltage */
\r
465 errorstate = SD_PowerON(hsd);
\r
467 if(errorstate != SD_OK)
\r
472 /* Initialize the present SDIO card(s) and put them in idle state */
\r
473 errorstate = SD_Initialize_Cards(hsd);
\r
475 if (errorstate != SD_OK)
\r
480 /* Read CSD/CID MSD registers */
\r
481 errorstate = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
\r
483 if (errorstate == SD_OK)
\r
485 /* Select the Card */
\r
486 errorstate = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
\r
489 /* Configure SDIO peripheral interface */
\r
490 SDIO_Init(hsd->Instance, hsd->Init);
\r
496 * @brief De-Initializes the SD card.
\r
497 * @param hsd: SD handle
\r
498 * @retval HAL status
\r
500 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
\r
503 /* Set SD power state to off */
\r
506 /* De-Initialize the MSP layer */
\r
507 HAL_SD_MspDeInit(hsd);
\r
514 * @brief Initializes the SD MSP.
\r
515 * @param hsd: SD handle
\r
518 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
\r
520 /* NOTE : This function Should not be modified, when the callback is needed,
\r
521 the HAL_SD_MspInit could be implemented in the user file
\r
526 * @brief De-Initialize SD MSP.
\r
527 * @param hsd: SD handle
\r
530 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
\r
532 /* NOTE : This function Should not be modified, when the callback is needed,
\r
533 the HAL_SD_MspDeInit could be implemented in the user file
\r
541 /** @addtogroup SD_Exported_Functions_Group2
\r
542 * @brief Data transfer functions
\r
545 ==============================================================================
\r
546 ##### IO operation functions #####
\r
547 ==============================================================================
\r
549 This subsection provides a set of functions allowing to manage the data
\r
550 transfer from/to SD card.
\r
557 * @brief Reads block(s) from a specified address in a card. The Data transfer
\r
558 * is managed by polling mode.
\r
559 * @param hsd: SD handle
\r
560 * @param pReadBuffer: pointer to the buffer that will contain the received data
\r
561 * @param ReadAddr: Address from where data is to be read
\r
562 * @param BlockSize: SD card Data block size
\r
563 * @note BlockSize must be 512 bytes.
\r
564 * @param NumberOfBlocks: Number of SD blocks to read
\r
565 * @retval SD Card error state
\r
567 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
569 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
570 SDIO_DataInitTypeDef sdmmc_datainitstructure;
\r
571 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
572 uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
\r
573 __IO uint32_t *pulFIFO = &( hsd->Instance->FIFO );
\r
575 /* Initialize data control register */
\r
576 hsd->Instance->DCTRL = 0;
\r
578 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
584 /* Set Block Size for Card */
\r
585 sdmmc_cmdinitstructure.Argument = (uint32_t) BlockSize;
\r
586 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
587 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
588 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
589 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
590 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
592 /* Check for error conditions */
\r
593 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
595 if (errorstate != SD_OK)
\r
600 /* Configure the SD DPSM (Data Path State Machine) */
\r
601 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
\r
602 sdmmc_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
\r
603 sdmmc_datainitstructure.DataBlockSize = DATA_BLOCK_SIZE;
\r
604 sdmmc_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
605 sdmmc_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
606 sdmmc_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
\r
607 SDIO_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
\r
609 if(NumberOfBlocks > 1)
\r
611 /* Send CMD18 READ_MULT_BLOCK with argument data address */
\r
612 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
\r
616 /* Send CMD17 READ_SINGLE_BLOCK */
\r
617 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
\r
620 sdmmc_cmdinitstructure.Argument = (uint32_t)ReadAddr;
\r
621 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
623 /* Check for error conditions */
\r
624 errorstate = SD_CmdResp1Error(hsd, sdmmc_cmdinitstructure.CmdIndex);
\r
625 if (errorstate != SD_OK)
\r
630 /* Read block(s) in polling mode */
\r
631 if(NumberOfBlocks > 1)
\r
633 /* Poll on SDIO flags */
\r
634 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
\r
636 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
638 /* Read data from SDIO Rx FIFO */
\r
639 tempbuff[0] = *( pulFIFO );
\r
640 tempbuff[1] = *( pulFIFO );
\r
641 tempbuff[2] = *( pulFIFO );
\r
642 tempbuff[3] = *( pulFIFO );
\r
643 tempbuff[4] = *( pulFIFO );
\r
644 tempbuff[5] = *( pulFIFO );
\r
645 tempbuff[6] = *( pulFIFO );
\r
646 tempbuff[7] = *( pulFIFO );
\r
654 /* In case of single block transfer, no need of stop transfer at all */
\r
655 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
\r
657 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
659 /* Read data from SDIO Rx FIFO */
\r
660 tempbuff[0] = *( pulFIFO );
\r
661 tempbuff[1] = *( pulFIFO );
\r
662 tempbuff[2] = *( pulFIFO );
\r
663 tempbuff[3] = *( pulFIFO );
\r
664 tempbuff[4] = *( pulFIFO );
\r
665 tempbuff[5] = *( pulFIFO );
\r
666 tempbuff[6] = *( pulFIFO );
\r
667 tempbuff[7] = *( pulFIFO );
\r
674 /* Send stop transmission command in case of multiblock read */
\r
675 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
\r
677 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
\r
678 (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
679 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
681 /* Send stop transmission command */
\r
682 errorstate = HAL_SD_StopTransfer(hsd);
\r
686 /* Get error state */
\r
687 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
689 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
691 errorstate = SD_DATA_TIMEOUT;
\r
695 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
697 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
699 errorstate = SD_DATA_CRC_FAIL;
\r
703 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
705 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
707 errorstate = SD_RX_OVERRUN;
\r
713 /* Note that the STM32F7 doesn't have a SDIO_FLAG_STBITERR flag. */
\r
714 /* No error flag set */
\r
717 count = SD_DATATIMEOUT;
\r
719 /* Empty FIFO if there is still any data */
\r
720 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
\r
722 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
\r
727 /* Clear all the static flags */
\r
728 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
734 * @brief Allows to write block(s) to a specified address in a card. The Data
\r
735 * transfer is managed by polling mode.
\r
736 * @param hsd: SD handle
\r
737 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
\r
738 * @param WriteAddr: Address from where data is to be written
\r
739 * @param BlockSize: SD card Data block size
\r
740 * @note BlockSize must be 512 bytes.
\r
741 * @param NumberOfBlocks: Number of SD blocks to write
\r
742 * @retval SD Card error state
\r
744 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
746 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
747 /*SDIO_DataInitTypeDef sdmmc_datainitstructure; */
\r
748 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
749 uint32_t totalnumberofbytes, bytesRemaining;
\r
752 uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
\r
753 uint8_t cardstate = 0;
\r
754 __IO uint32_t *pulFIFO = &( hsd->Instance->FIFO );
\r
755 uint32_t ulEndFags;
\r
756 uint32_t ulHasHWFlowControl;
\r
758 /* Initialize data control register */
\r
759 hsd->Instance->DCTRL = 0;
\r
761 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
767 /* Set Block Size for Card */
\r
768 sdmmc_cmdinitstructure.Argument = (uint32_t)BlockSize;
\r
769 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
770 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
771 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
772 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
773 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
775 /* Check for error conditions */
\r
776 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
778 if (errorstate != SD_OK)
\r
783 if(NumberOfBlocks > 1)
\r
785 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
\r
786 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
\r
787 /* Test for DATAEND : Data end (data counter, SDID count) is zero) */
\r
788 ulEndFags = SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND;
\r
792 /* Send CMD24 WRITE_SINGLE_BLOCK */
\r
793 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
\r
794 /* Test for DBCKEND : Data Block Sent/Received (CRC check passed) */
\r
795 ulEndFags = SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND;
\r
797 ulEndFags |= SDIO_FLAG_TXUNDERR;
\r
799 sdmmc_cmdinitstructure.Argument = (uint32_t)WriteAddr;
\r
800 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
802 /* Check for error conditions */
\r
803 errorstate = SD_CmdResp1Error(hsd, sdmmc_cmdinitstructure.CmdIndex);
\r
804 if (errorstate != SD_OK)
\r
809 ulHasHWFlowControl = ( hsd->Instance->CLKCR & SDIO_HARDWARE_FLOW_CONTROL_ENABLE ) != 0;
\r
811 /* Set total number of bytes to write */
\r
812 totalnumberofbytes = NumberOfBlocks * BlockSize;
\r
813 bytesRemaining = 4 * ( ( totalnumberofbytes + 3 ) / 4 );
\r
815 /* Configure the SD DPSM (Data Path State Machine) */
\r
817 sdio_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
\r
818 sdio_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
\r
819 sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
\r
820 sdio_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
\r
821 sdio_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
822 sdio_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
\r
823 SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
\r
825 /* Set the SDIO Data Timeout value */
\r
826 hsd->Instance->DTIMER = SD_DATATIMEOUT;
\r
828 /* Set the SDIO DataLength value */
\r
829 hsd->Instance->DLEN = NumberOfBlocks * BlockSize;
\r
831 tmpreg = hsd->Instance->DCTRL & ~( DCTRL_CLEAR_MASK );
\r
832 /* Set the SDIO data configuration parameters */
\r
833 tmpreg |= (uint32_t)(SDIO_DATABLOCK_SIZE_512B | SDIO_TRANSFER_DIR_TO_CARD | SDIO_TRANSFER_MODE_BLOCK | SDIO_DCTRL_DTEN);
\r
835 /* Write to SDIO DCTRL */
\r
837 hsd->Instance->DCTRL = tmpreg;
\r
841 last_sta = hsd->Instance->STA;
\r
842 if( ( last_sta & ( SDIO_FLAG_TXFIFOHE | SDIO_FLAG_TXFIFOE ) ) != 0 )
\r
844 /* SDIO_FLAG_TXFIFOHE: Transmit FIFO Half Empty
\r
845 May write 32 bytes. */
\r
846 if( bytesRemaining < 32)
\r
848 /* Write data to SDIO Tx FIFO */
\r
849 while( bytesRemaining > 0 )
\r
851 *pulFIFO = *( tempbuff++ );
\r
852 bytesRemaining -= 4;
\r
857 /* Write data to SDIO Tx FIFO */
\r
858 *pulFIFO = tempbuff[ 0 ];
\r
859 *pulFIFO = tempbuff[ 1 ];
\r
860 *pulFIFO = tempbuff[ 2 ];
\r
861 *pulFIFO = tempbuff[ 3 ];
\r
862 *pulFIFO = tempbuff[ 4 ];
\r
863 *pulFIFO = tempbuff[ 5 ];
\r
864 *pulFIFO = tempbuff[ 6 ];
\r
865 *pulFIFO = tempbuff[ 7 ];
\r
868 bytesRemaining -= 32;
\r
869 if( ( last_sta & SDIO_FLAG_TXFIFOE ) != 0 )
\r
871 /* SDIO_FLAG_TXFIFOE: Transmit FIFO empty
\r
872 May write 24 or 32 extra bytes, depending on
\r
873 ulHasHWFlowControl. */
\r
874 *pulFIFO = tempbuff[ 0 ];
\r
875 *pulFIFO = tempbuff[ 1 ];
\r
876 *pulFIFO = tempbuff[ 2 ];
\r
877 *pulFIFO = tempbuff[ 3 ];
\r
878 *pulFIFO = tempbuff[ 4 ];
\r
879 *pulFIFO = tempbuff[ 5 ];
\r
880 if( ulHasHWFlowControl != 0 )
\r
883 bytesRemaining -= 24;
\r
887 *pulFIFO = tempbuff[ 6 ];
\r
888 *pulFIFO = tempbuff[ 7 ];
\r
891 bytesRemaining -= 32;
\r
896 if( ( last_sta & ulEndFags ) != 0 )
\r
901 if( ( ( last_sta & SDIO_FLAG_TXUNDERR ) != 0 ) || ( bytesRemaining != 0 ) )
\r
903 FF_PRINTF("TX underflow %lu < %lu\n", bytesRemaining, totalnumberofbytes );
\r
905 /* Send stop transmission command in case of multiblock write */
\r
906 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
\r
908 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
909 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
911 /* Send stop transmission command */
\r
912 errorstate = HAL_SD_StopTransfer(hsd);
\r
916 /* Get error state */
\r
917 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
919 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
921 errorstate = SD_DATA_TIMEOUT;
\r
925 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
927 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
929 errorstate = SD_DATA_CRC_FAIL;
\r
933 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
\r
935 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
\r
937 errorstate = SD_TX_UNDERRUN;
\r
943 /* Note that the STM32F7 doesn't have a SDIO_FLAG_STBITERR flag. */
\r
944 /* No error flag set */
\r
947 /* Clear all the static flags */
\r
948 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
950 /* Wait till the card is in programming state */
\r
953 errorstate = SD_IsCardProgramming(hsd, &cardstate);
\r
954 } while ((errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)));
\r
960 * @brief Reads block(s) from a specified address in a card. The Data transfer
\r
961 * is managed by DMA mode.
\r
962 * @note This API should be followed by the function HAL_SD_CheckReadOperation()
\r
963 * to check the completion of the read process
\r
964 * @param hsd: SD handle
\r
965 * @param pReadBuffer: Pointer to the buffer that will contain the received data
\r
966 * @param ReadAddr: Address from where data is to be read
\r
967 * @param BlockSize: SD card Data block size
\r
968 * @note BlockSize must be 512 bytes.
\r
969 * @param NumberOfBlocks: Number of blocks to read.
\r
970 * @retval SD Card error state
\r
972 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
974 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
975 SDIO_DataInitTypeDef sdmmc_datainitstructure;
\r
976 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
978 /* Initialize data control register */
\r
979 hsd->Instance->DCTRL = 0;
\r
981 /* Initialize handle flags */
\r
982 hsd->SdTransferCplt = 0;
\r
983 hsd->DmaTransferCplt = 0;
\r
984 hsd->SdTransferErr = SD_OK;
\r
985 if( hsd->EventSetupFunction != NULL )
\r
987 hsd->EventSetupFunction( hsd );
\r
990 /* Initialize SD Read operation */
\r
991 if(NumberOfBlocks > 1)
\r
993 hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
\r
997 hsd->SdOperation = SD_READ_SINGLE_BLOCK;
\r
1000 /* Enable transfer interrupts */
\r
1001 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
\r
1002 SDIO_IT_DTIMEOUT |\
\r
1003 SDIO_IT_DATAEND |\
\r
1004 SDIO_IT_RXOVERR));
\r
1006 /* Enable SDIO DMA transfer */
\r
1007 __HAL_SD_SDIO_DMA_ENABLE(hsd);
\r
1009 /* Configure DMA user callbacks */
\r
1010 hsd->hdmarx->XferCpltCallback = SD_DMA_RxCplt;
\r
1011 hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
\r
1013 /* Enable the DMA Stream */
\r
1014 HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks)/4);
\r
1016 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
1022 /* Set Block Size for Card */
\r
1023 sdmmc_cmdinitstructure.Argument = (uint32_t)BlockSize;
\r
1024 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
1025 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
1026 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1027 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
1028 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1030 /* Check for error conditions */
\r
1031 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
1033 if (errorstate != SD_OK)
\r
1035 return errorstate;
\r
1038 /* Configure the SD DPSM (Data Path State Machine) */
\r
1039 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
\r
1040 sdmmc_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
\r
1041 sdmmc_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
\r
1042 sdmmc_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
1043 sdmmc_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
1044 sdmmc_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
\r
1045 SDIO_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
\r
1047 /* Check number of blocks command */
\r
1048 if(NumberOfBlocks > 1)
\r
1050 /* Send CMD18 READ_MULT_BLOCK with argument data address */
\r
1051 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
\r
1055 /* Send CMD17 READ_SINGLE_BLOCK */
\r
1056 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
\r
1059 sdmmc_cmdinitstructure.Argument = (uint32_t)ReadAddr;
\r
1060 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1062 /* Check for error conditions */
\r
1063 errorstate = SD_CmdResp1Error(hsd, sdmmc_cmdinitstructure.CmdIndex);
\r
1065 /* Update the SD transfer error in SD handle */
\r
1066 hsd->SdTransferErr = errorstate;
\r
1068 return errorstate;
\r
1073 * @brief Writes block(s) to a specified address in a card. The Data transfer
\r
1074 * is managed by DMA mode.
\r
1075 * @note This API should be followed by the function HAL_SD_CheckWriteOperation()
\r
1076 * to check the completion of the write process (by SD current status polling).
\r
1077 * @param hsd: SD handle
\r
1078 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
\r
1079 * @param WriteAddr: Address from where data is to be read
\r
1080 * @param BlockSize: the SD card Data block size
\r
1081 * @note BlockSize must be 512 bytes.
\r
1082 * @param NumberOfBlocks: Number of blocks to write
\r
1083 * @retval SD Card error state
\r
1085 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
\r
1087 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
1088 /*SDIO_DataInitTypeDef sdmmc_datainitstructure;*/
\r
1089 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1092 /* Initialize data control register */
\r
1093 hsd->Instance->DCTRL = 0;
\r
1095 /* Initialize handle flags */
\r
1096 hsd->SdTransferCplt = 0;
\r
1097 hsd->DmaTransferCplt = 0;
\r
1098 hsd->SdTransferErr = SD_OK;
\r
1099 if( hsd->EventSetupFunction != NULL )
\r
1101 hsd->EventSetupFunction( hsd );
\r
1104 hsd->Instance->DLEN = NumberOfBlocks * BlockSize;
\r
1106 /* Initialize SD Write operation */
\r
1107 if(NumberOfBlocks > 1)
\r
1109 hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
\r
1113 hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
\r
1116 /* Enable transfer interrupts */
\r
1117 __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
\r
1118 SDIO_IT_DTIMEOUT |\
\r
1119 SDIO_IT_DATAEND |\
\r
1120 SDIO_IT_TXUNDERR));
\r
1122 /* Configure DMA user callbacks */
\r
1123 hsd->hdmatx->XferCpltCallback = SD_DMA_TxCplt;
\r
1124 hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
\r
1126 /* Enable the DMA Stream */
\r
1127 HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BlockSize * NumberOfBlocks)/4);
\r
1129 /* Enable SDIO DMA transfer */
\r
1130 __HAL_SD_SDIO_DMA_ENABLE(hsd);
\r
1132 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
1138 /* Set Block Size for Card */
\r
1139 sdmmc_cmdinitstructure.Argument = (uint32_t)BlockSize;
\r
1140 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
1141 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
1142 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1143 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
1144 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1146 /* Check for error conditions */
\r
1147 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
1149 if (errorstate != SD_OK)
\r
1151 return errorstate;
\r
1154 /* Check number of blocks command */
\r
1155 if(NumberOfBlocks <= 1)
\r
1157 /* Send CMD24 WRITE_SINGLE_BLOCK */
\r
1158 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
\r
1162 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
\r
1163 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
\r
1166 sdmmc_cmdinitstructure.Argument = (uint32_t)WriteAddr;
\r
1167 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1169 /* Check for error conditions */
\r
1170 errorstate = SD_CmdResp1Error(hsd, sdmmc_cmdinitstructure.CmdIndex);
\r
1172 if (errorstate != SD_OK)
\r
1174 return errorstate;
\r
1177 /* Configure the SD DPSM (Data Path State Machine) */
\r
1179 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
\r
1180 sdmmc_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
\r
1181 sdmmc_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
\r
1182 sdmmc_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
\r
1183 sdmmc_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
1184 sdmmc_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
\r
1185 SDIO_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
\r
1188 /* Set the SDIO Data Timeout value */
\r
1189 hsd->Instance->DTIMER = SD_DATATIMEOUT;
\r
1191 // /* Set the SDIO DataLength value */
\r
1192 // hsd->Instance->DLEN = NumberOfBlocks * BlockSize;
\r
1194 tmpreg = hsd->Instance->DCTRL & ~( DCTRL_CLEAR_MASK );
\r
1195 /* Set the SDIO data configuration parameters */
\r
1196 tmpreg |= (uint32_t)(SDIO_DATABLOCK_SIZE_512B | SDIO_TRANSFER_DIR_TO_CARD | SDIO_TRANSFER_MODE_BLOCK | SDIO_DCTRL_DTEN);
\r
1198 /* Write to SDIO DCTRL */
\r
1199 hsd->Instance->DCTRL = tmpreg;
\r
1201 hsd->SdTransferErr = errorstate;
\r
1203 return errorstate;
\r
1207 * @brief This function waits until the SD DMA data read transfer is finished.
\r
1208 * This API should be called after HAL_SD_ReadBlocks_DMA() function
\r
1209 * to insure that all data sent by the card is already transferred by the
\r
1211 * @param hsd: SD handle
\r
1212 * @param Timeout: Timeout duration
\r
1213 * @retval SD Card error state
\r
1216 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t ulMaxTime)
\r
1218 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1219 uint32_t ulStarted = xTaskGetTickCount( );
\r
1220 BaseType_t xHadTimeout = pdFALSE;
\r
1222 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
\r
1226 HAL_SD_ErrorTypedef xError;
\r
1227 if( ( hsd->DmaTransferCplt != 0 ) && ( hsd->SdTransferCplt != 0 ) )
\r
1229 HAL_DMA_Abort( hsd->hdmarx );
\r
1232 xError = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
\r
1233 if( xError != SD_OK )
\r
1237 if( hsd->EventWaitFunction != NULL )
\r
1239 if( hsd->EventWaitFunction( ( void * ) hsd ) != 0 )
\r
1241 FF_PRINTF( "EventWaitFunction: RX timeout!\n" );
\r
1242 /* A timeout is reached. */
\r
1248 if( ( xTaskGetTickCount( ) - ulStarted ) >= ulMaxTime )
\r
1250 xHadTimeout = pdTRUE;
\r
1256 ulStarted = xTaskGetTickCount( );
\r
1258 /* Wait until the Rx transfer is no longer active */
\r
1259 while(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXACT))
\r
1261 if( ( xTaskGetTickCount( ) - ulStarted ) >= ulMaxTime )
\r
1263 xHadTimeout = pdTRUE;
\r
1268 /* Send stop command in multiblock read */
\r
1269 if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
\r
1271 errorstate = HAL_SD_StopTransfer(hsd);
\r
1274 if ((xHadTimeout != pdFALSE) && (errorstate == SD_OK))
\r
1276 errorstate = SD_DATA_TIMEOUT;
\r
1279 /* Clear all the static flags */
\r
1280 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
1282 /* Return error state */
\r
1283 if (hsd->SdTransferErr != SD_OK)
\r
1285 return (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
\r
1288 return errorstate;
\r
1292 * @brief This function waits until the SD DMA data write transfer is finished.
\r
1293 * This API should be called after HAL_SD_WriteBlocks_DMA() function
\r
1294 * to insure that all data sent by the card is already transferred by the
\r
1296 * @param hsd: SD handle
\r
1297 * @param Timeout: Timeout duration
\r
1298 * @retval SD Card error state
\r
1300 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t ulMaxTime)
\r
1302 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1303 uint32_t ulStarted = 0;
\r
1304 BaseType_t xHadTimeout = pdFALSE;
\r
1305 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
\r
1309 HAL_SD_ErrorTypedef xError;
\r
1310 if( ( hsd->DmaTransferCplt != 0 ) && ( hsd->SdTransferCplt != 0 ) )
\r
1312 HAL_DMA_Abort( hsd->hdmatx );
\r
1315 xError = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
\r
1316 if( xError != SD_OK )
\r
1320 if( hsd->EventWaitFunction != NULL )
\r
1322 if( hsd->EventWaitFunction( ( void * ) hsd ) != 0 )
\r
1324 FF_PRINTF( "EventWaitFunction: TX timeout!\n" );
\r
1325 /* A timeout is reached. */
\r
1331 if( ( xTaskGetTickCount( ) - ulStarted ) >= ulMaxTime )
\r
1333 xHadTimeout = pdTRUE;
\r
1339 ulStarted = xTaskGetTickCount( );
\r
1341 /* Wait until the Tx transfer is no longer active */
\r
1342 /* while( ( hsd->Instance->STA & SDIO_FLAG_TXACT ) != 0 ) { } */
\r
1343 while( __HAL_SD_SDIO_GET_FLAG( hsd, SDIO_FLAG_TXACT ) )
\r
1345 if( ( xTaskGetTickCount( ) - ulStarted ) >= ulMaxTime )
\r
1347 xHadTimeout = pdTRUE;
\r
1352 /* Send stop command in multiblock write */
\r
1353 if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
\r
1355 errorstate = HAL_SD_StopTransfer(hsd);
\r
1358 if( ( xHadTimeout != pdFALSE ) && ( errorstate == SD_OK ) )
\r
1360 errorstate = SD_DATA_TIMEOUT;
\r
1363 /* Clear all the static flags */
\r
1364 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
1366 /* Return error state */
\r
1367 if (hsd->SdTransferErr != SD_OK)
\r
1369 errorstate = (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
\r
1373 /* Wait until write is complete */
\r
1374 while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
\r
1379 return errorstate;
\r
1383 * @brief Erases the specified memory area of the given SD card.
\r
1384 * @param hsd: SD handle
\r
1385 * @param startaddr: Start byte address
\r
1386 * @param endaddr: End byte address
\r
1387 * @retval SD Card error state
\r
1389 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
\r
1391 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1392 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
1394 uint32_t delay = 0;
\r
1395 __IO uint32_t maxdelay = 0;
\r
1396 uint8_t cardstate = 0;
\r
1398 /* Check if the card command class supports erase command */
\r
1399 if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
\r
1401 errorstate = SD_REQUEST_NOT_APPLICABLE;
\r
1403 return errorstate;
\r
1406 /* Get max delay value */
\r
1407 maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
\r
1409 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
1411 errorstate = SD_LOCK_UNLOCK_FAILED;
\r
1413 return errorstate;
\r
1416 /* Get start and end block for high capacity cards */
\r
1417 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
1423 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
\r
1424 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
1425 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
1427 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
\r
1428 sdmmc_cmdinitstructure.Argument =(uint32_t)startaddr;
\r
1429 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_START;
\r
1430 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
1431 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1432 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
1433 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1435 /* Check for error conditions */
\r
1436 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
\r
1438 if (errorstate != SD_OK)
\r
1440 return errorstate;
\r
1443 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
\r
1444 sdmmc_cmdinitstructure.Argument = (uint32_t)endaddr;
\r
1445 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_END;
\r
1446 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1448 /* Check for error conditions */
\r
1449 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
\r
1451 if (errorstate != SD_OK)
\r
1453 return errorstate;
\r
1457 /* Send CMD38 ERASE */
\r
1458 sdmmc_cmdinitstructure.Argument = 0;
\r
1459 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_ERASE;
\r
1460 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1462 /* Check for error conditions */
\r
1463 errorstate = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
\r
1465 if (errorstate != SD_OK)
\r
1467 return errorstate;
\r
1470 for (; delay < maxdelay; delay++)
\r
1474 /* Wait until the card is in programming state */
\r
1475 errorstate = SD_IsCardProgramming(hsd, &cardstate);
\r
1477 delay = SD_DATATIMEOUT;
\r
1479 while ((delay > 0) && (errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
\r
1481 errorstate = SD_IsCardProgramming(hsd, &cardstate);
\r
1485 return errorstate;
\r
1489 * @brief This function handles SD card interrupt request.
\r
1490 * @param hsd: SD handle
\r
1493 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
\r
1495 /* Check for SDIO interrupt flags */
\r
1496 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DATAEND))
\r
1498 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_IT_DATAEND);
\r
1500 /* SD transfer is complete */
\r
1501 hsd->SdTransferCplt = 1;
\r
1503 /* No transfer error */
\r
1504 hsd->SdTransferErr = SD_OK;
\r
1506 HAL_SD_XferCpltCallback(hsd);
\r
1508 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DCRCFAIL))
\r
1510 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
1512 hsd->SdTransferErr = SD_DATA_CRC_FAIL;
\r
1514 HAL_SD_XferErrorCallback(hsd);
\r
1517 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DTIMEOUT))
\r
1519 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
1521 hsd->SdTransferErr = SD_DATA_TIMEOUT;
\r
1523 HAL_SD_XferErrorCallback(hsd);
\r
1525 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_RXOVERR))
\r
1527 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
1529 hsd->SdTransferErr = SD_RX_OVERRUN;
\r
1531 HAL_SD_XferErrorCallback(hsd);
\r
1533 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_TXUNDERR))
\r
1535 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
\r
1537 hsd->SdTransferErr = SD_TX_UNDERRUN;
\r
1539 HAL_SD_XferErrorCallback(hsd);
\r
1543 /* No error flag set */
\r
1546 /* Disable all SDIO peripheral interrupt sources */
\r
1547 __HAL_SD_SDIO_DISABLE_IT(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |\
\r
1548 SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |\
\r
1554 * @brief SD end of transfer callback.
\r
1555 * @param hsd: SD handle
\r
1558 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
\r
1560 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1561 the HAL_SD_XferCpltCallback could be implemented in the user file
\r
1566 * @brief SD Transfer Error callback.
\r
1567 * @param hsd: SD handle
\r
1570 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
\r
1572 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1573 the HAL_SD_XferErrorCallback could be implemented in the user file
\r
1578 * @brief SD Transfer complete Rx callback in non blocking mode.
\r
1579 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
1580 * the configuration information for the specified DMA module.
\r
1583 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
\r
1585 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1586 the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
\r
1591 * @brief SD DMA transfer complete Rx error callback.
\r
1592 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
1593 * the configuration information for the specified DMA module.
\r
1596 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
\r
1598 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1599 the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
\r
1604 * @brief SD Transfer complete Tx callback in non blocking mode.
\r
1605 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
1606 * the configuration information for the specified DMA module.
\r
1609 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
\r
1611 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1612 the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
\r
1617 * @brief SD DMA transfer complete error Tx callback.
\r
1618 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
1619 * the configuration information for the specified DMA module.
\r
1622 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
\r
1624 /* NOTE : This function Should not be modified, when the callback is needed,
\r
1625 the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
\r
1633 /** @addtogroup SD_Exported_Functions_Group3
\r
1634 * @brief management functions
\r
1637 ==============================================================================
\r
1638 ##### Peripheral Control functions #####
\r
1639 ==============================================================================
\r
1641 This subsection provides a set of functions allowing to control the SD card
\r
1649 * @brief Returns information about specific card.
\r
1650 * @param hsd: SD handle
\r
1651 * @param pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
\r
1652 * contains all SD cardinformation
\r
1653 * @retval SD Card error state
\r
1655 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
\r
1657 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1660 pCardInfo->CardType = (uint8_t)(hsd->CardType);
\r
1661 pCardInfo->RCA = (uint16_t)(hsd->RCA);
\r
1664 tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
\r
1665 pCardInfo->SD_csd.CSDStruct = (uint8_t)((tmp & 0xC0) >> 6);
\r
1666 pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
\r
1667 pCardInfo->SD_csd.Reserved1 = tmp & 0x03;
\r
1670 tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
\r
1671 pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
\r
1674 tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
\r
1675 pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
\r
1678 tmp = hsd->CSD[0] & 0x000000FF;
\r
1679 pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
\r
1682 tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
\r
1683 pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
\r
1686 tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
\r
1687 pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
\r
1688 pCardInfo->SD_csd.RdBlockLen = (uint8_t)(tmp & 0x0F);
\r
1691 tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
\r
1692 pCardInfo->SD_csd.PartBlockRead = (uint8_t)((tmp & 0x80) >> 7);
\r
1693 pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
\r
1694 pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
\r
1695 pCardInfo->SD_csd.DSRImpl = (uint8_t)((tmp & 0x10) >> 4);
\r
1696 pCardInfo->SD_csd.Reserved2 = 0; /*!< Reserved */
\r
1698 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
\r
1700 pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
\r
1703 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
\r
1704 pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
\r
1707 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
\r
1708 pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
\r
1710 pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
\r
1711 pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
\r
1714 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
\r
1715 pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
\r
1716 pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
\r
1717 pCardInfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
\r
1719 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
\r
1720 pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
\r
1722 pCardInfo->CardCapacity = (pCardInfo->SD_csd.DeviceSize + 1) ;
\r
1723 pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
\r
1724 pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
\r
1725 pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
\r
1727 else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
\r
1730 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
\r
1731 pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
\r
1734 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
\r
1736 pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
\r
1739 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
\r
1741 pCardInfo->SD_csd.DeviceSize |= (tmp);
\r
1744 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
\r
1746 pCardInfo->CardCapacity = (uint64_t)((((uint64_t)pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024);
\r
1747 pCardInfo->CardBlockSize = 512;
\r
1751 /* Not supported card type */
\r
1752 errorstate = SD_ERROR;
\r
1755 pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
\r
1756 pCardInfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
\r
1759 tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
\r
1760 pCardInfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
\r
1761 pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
\r
1764 tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
\r
1765 pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
\r
1766 pCardInfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
\r
1767 pCardInfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
\r
1768 pCardInfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
\r
1771 tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
\r
1772 pCardInfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
\r
1773 pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
\r
1774 pCardInfo->SD_csd.Reserved3 = 0;
\r
1775 pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
\r
1778 tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
\r
1779 pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
\r
1780 pCardInfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
\r
1781 pCardInfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
\r
1782 pCardInfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
\r
1783 pCardInfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
\r
1784 pCardInfo->SD_csd.ECC = (tmp & 0x03);
\r
1787 tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
\r
1788 pCardInfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
\r
1789 pCardInfo->SD_csd.Reserved4 = 1;
\r
1792 tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
\r
1793 pCardInfo->SD_cid.ManufacturerID = tmp;
\r
1796 tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
\r
1797 pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
\r
1800 tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
\r
1801 pCardInfo->SD_cid.OEM_AppliID |= tmp;
\r
1804 tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
\r
1805 pCardInfo->SD_cid.ProdName1 = tmp << 24;
\r
1808 tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
\r
1809 pCardInfo->SD_cid.ProdName1 |= tmp << 16;
\r
1812 tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
\r
1813 pCardInfo->SD_cid.ProdName1 |= tmp << 8;
\r
1816 tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
\r
1817 pCardInfo->SD_cid.ProdName1 |= tmp;
\r
1820 tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
\r
1821 pCardInfo->SD_cid.ProdName2 = tmp;
\r
1824 tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
\r
1825 pCardInfo->SD_cid.ProdRev = tmp;
\r
1828 tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
\r
1829 pCardInfo->SD_cid.ProdSN = tmp << 24;
\r
1832 tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
\r
1833 pCardInfo->SD_cid.ProdSN |= tmp << 16;
\r
1836 tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
\r
1837 pCardInfo->SD_cid.ProdSN |= tmp << 8;
\r
1840 tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
\r
1841 pCardInfo->SD_cid.ProdSN |= tmp;
\r
1844 tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
\r
1845 pCardInfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
\r
1846 pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
\r
1849 tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
\r
1850 pCardInfo->SD_cid.ManufactDate |= tmp;
\r
1853 tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
\r
1854 pCardInfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
\r
1855 pCardInfo->SD_cid.Reserved2 = 1;
\r
1857 return errorstate;
\r
1861 * @brief Enables wide bus operation for the requested card if supported by
\r
1863 * @param hsd: SD handle
\r
1864 * @param WideMode: Specifies the SD card wide bus mode
\r
1865 * This parameter can be one of the following values:
\r
1866 * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
\r
1867 * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
\r
1868 * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
\r
1869 * @retval SD Card error state
\r
1871 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
\r
1873 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1874 SDIO_InitTypeDef tmpinit;
\r
1876 /* MMC Card does not support this feature */
\r
1877 if (hsd->CardType == MULTIMEDIA_CARD)
\r
1879 errorstate = SD_UNSUPPORTED_FEATURE;
\r
1881 return errorstate;
\r
1883 else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
1884 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
1886 if (WideMode == SDIO_BUS_WIDE_8B)
\r
1888 errorstate = SD_UNSUPPORTED_FEATURE;
\r
1890 else if (WideMode == SDIO_BUS_WIDE_4B)
\r
1892 errorstate = SD_WideBus_Enable(hsd);
\r
1894 else if (WideMode == SDIO_BUS_WIDE_1B)
\r
1896 errorstate = SD_WideBus_Disable(hsd);
\r
1900 /* WideMode is not a valid argument*/
\r
1901 errorstate = SD_INVALID_PARAMETER;
\r
1904 if (errorstate == SD_OK)
\r
1906 /* Configure the SDIO peripheral */
\r
1907 tmpinit.ClockEdge = hsd->Init.ClockEdge;
\r
1908 tmpinit.ClockBypass = hsd->Init.ClockBypass;
\r
1909 tmpinit.ClockPowerSave = hsd->Init.ClockPowerSave;
\r
1910 tmpinit.BusWide = WideMode;
\r
1911 tmpinit.HardwareFlowControl = hsd->Init.HardwareFlowControl;
\r
1912 tmpinit.ClockDiv = hsd->Init.ClockDiv;
\r
1913 SDIO_Init(hsd->Instance, tmpinit);
\r
1917 return errorstate;
\r
1921 * @brief Aborts an ongoing data transfer.
\r
1922 * @param hsd: SD handle
\r
1923 * @retval SD Card error state
\r
1925 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
\r
1927 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
1928 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1930 /* Send CMD12 STOP_TRANSMISSION */
\r
1931 sdmmc_cmdinitstructure.Argument = 0;
\r
1932 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_STOP_TRANSMISSION;
\r
1933 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
1934 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1935 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
1936 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1938 /* Check for error conditions */
\r
1939 errorstate = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
\r
1941 return errorstate;
\r
1945 * @brief Switches the SD card to High Speed mode.
\r
1946 * This API must be used after "Transfer State"
\r
1947 * @note This operation should be followed by the configuration
\r
1948 * of PLL to have SDIOCK clock between 67 and 75 MHz
\r
1949 * @param hsd: SD handle
\r
1950 * @retval SD Card error state
\r
1952 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
\r
1954 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
1955 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
1956 SDIO_DataInitTypeDef sdmmc_datainitstructure;
\r
1958 uint8_t SD_hs[64] = {0};
\r
1959 uint32_t SD_scr[2] = {0, 0};
\r
1960 uint32_t SD_SPEC = 0 ;
\r
1961 uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
\r
1963 /* Initialize the Data control register */
\r
1964 hsd->Instance->DCTRL = 0;
\r
1966 /* Get SCR Register */
\r
1967 errorstate = SD_FindSCR(hsd, SD_scr);
\r
1969 if (errorstate != SD_OK)
\r
1971 return errorstate;
\r
1974 /* Test the Version supported by the card*/
\r
1975 SD_SPEC = (SD_scr[1] & 0x01000000) | (SD_scr[1] & 0x02000000);
\r
1977 if (SD_SPEC != SD_ALLZERO)
\r
1979 /* Set Block Size for Card */
\r
1980 sdmmc_cmdinitstructure.Argument = (uint32_t)64;
\r
1981 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
1982 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
1983 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
1984 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
1985 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
1987 /* Check for error conditions */
\r
1988 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
1990 if (errorstate != SD_OK)
\r
1992 return errorstate;
\r
1995 /* Configure the SD DPSM (Data Path State Machine) */
\r
1996 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
\r
1997 sdmmc_datainitstructure.DataLength = 64;
\r
1998 sdmmc_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
\r
1999 sdmmc_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
2000 sdmmc_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
2001 sdmmc_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
\r
2002 SDIO_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
\r
2004 /* Send CMD6 switch mode */
\r
2005 sdmmc_cmdinitstructure.Argument = 0x80FFFF01;
\r
2006 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_HS_SWITCH;
\r
2007 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2009 /* Check for error conditions */
\r
2010 errorstate = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
\r
2012 if (errorstate != SD_OK)
\r
2014 return errorstate;
\r
2017 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
\r
2019 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
2021 for (count = 0; count < 8; count++)
\r
2023 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
\r
2030 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
2032 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
2034 errorstate = SD_DATA_TIMEOUT;
\r
2036 return errorstate;
\r
2038 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
2040 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
2042 errorstate = SD_DATA_CRC_FAIL;
\r
2044 return errorstate;
\r
2046 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
2048 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
2050 errorstate = SD_RX_OVERRUN;
\r
2052 return errorstate;
\r
2056 /* No error flag set */
\r
2059 count = SD_DATATIMEOUT;
\r
2061 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
\r
2063 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
\r
2068 /* Clear all the static flags */
\r
2069 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2071 /* Test if the switch mode HS is ok */
\r
2072 if ((SD_hs[13]& 2) != 2)
\r
2074 errorstate = SD_UNSUPPORTED_FEATURE;
\r
2078 return errorstate;
\r
2085 /** @addtogroup SD_Exported_Functions_Group4
\r
2086 * @brief Peripheral State functions
\r
2089 ==============================================================================
\r
2090 ##### Peripheral State functions #####
\r
2091 ==============================================================================
\r
2093 This subsection permits to get in runtime the status of the peripheral
\r
2094 and the data flow.
\r
2101 * @brief Returns the current SD card's status.
\r
2102 * @param hsd: SD handle
\r
2103 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
\r
2104 * SD Status register)
\r
2105 * @retval SD Card error state
\r
2107 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
\r
2109 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
2110 SDIO_DataInitTypeDef sdmmc_datainitstructure;
\r
2111 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2112 uint32_t count = 0;
\r
2114 /* Check SD response */
\r
2115 if ((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
2117 errorstate = SD_LOCK_UNLOCK_FAILED;
\r
2119 return errorstate;
\r
2122 /* Set block size for card if it is not equal to current block size for card */
\r
2123 sdmmc_cmdinitstructure.Argument = 64;
\r
2124 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
2125 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
2126 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2127 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
2128 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2130 /* Check for error conditions */
\r
2131 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
2133 if (errorstate != SD_OK)
\r
2135 return errorstate;
\r
2139 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
2140 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
\r
2141 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2143 /* Check for error conditions */
\r
2144 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
2146 if (errorstate != SD_OK)
\r
2148 return errorstate;
\r
2151 /* Configure the SD DPSM (Data Path State Machine) */
\r
2152 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
\r
2153 sdmmc_datainitstructure.DataLength = 64;
\r
2154 sdmmc_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
\r
2155 sdmmc_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
2156 sdmmc_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
2157 sdmmc_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
\r
2158 SDIO_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
\r
2160 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
\r
2161 sdmmc_cmdinitstructure.Argument = 0;
\r
2162 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_STATUS;
\r
2163 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2165 /* Check for error conditions */
\r
2166 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STATUS);
\r
2168 if (errorstate != SD_OK)
\r
2170 return errorstate;
\r
2173 /* Get status data */
\r
2174 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
\r
2176 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
\r
2178 for (count = 0; count < 8; count++)
\r
2180 *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
\r
2187 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
2189 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
2191 errorstate = SD_DATA_TIMEOUT;
\r
2193 return errorstate;
\r
2195 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
2197 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
2199 errorstate = SD_DATA_CRC_FAIL;
\r
2201 return errorstate;
\r
2203 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
2205 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
2207 errorstate = SD_RX_OVERRUN;
\r
2209 return errorstate;
\r
2213 /* No error flag set */
\r
2216 count = SD_DATATIMEOUT;
\r
2217 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
\r
2219 *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
\r
2224 /* Clear all the static status flags*/
\r
2225 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2227 return errorstate;
\r
2231 * @brief Gets the current sd card data status.
\r
2232 * @param hsd: SD handle
\r
2233 * @retval Data Transfer state
\r
2235 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
\r
2237 HAL_SD_CardStateTypedef cardstate = SD_CARD_TRANSFER;
\r
2239 /* Get SD card state */
\r
2240 cardstate = SD_GetState(hsd);
\r
2242 /* Find SD status according to card state*/
\r
2243 if (cardstate == SD_CARD_TRANSFER)
\r
2245 return SD_TRANSFER_OK;
\r
2247 else if(cardstate == SD_CARD_ERROR)
\r
2249 return SD_TRANSFER_ERROR;
\r
2253 return SD_TRANSFER_BUSY;
\r
2258 * @brief Gets the SD card status.
\r
2259 * @param hsd: SD handle
\r
2260 * @param pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
\r
2261 * will contain the SD card status information
\r
2262 * @retval SD Card error state
\r
2264 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
\r
2266 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2268 uint32_t sd_status[16];
\r
2270 errorstate = HAL_SD_SendSDStatus(hsd, sd_status);
\r
2272 if (errorstate != SD_OK)
\r
2274 return errorstate;
\r
2278 tmp = (sd_status[0] & 0xC0) >> 6;
\r
2279 pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
\r
2282 tmp = (sd_status[0] & 0x20) >> 5;
\r
2283 pCardStatus->SECURED_MODE = (uint8_t)tmp;
\r
2286 tmp = (sd_status[2] & 0xFF);
\r
2287 pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
\r
2290 tmp = (sd_status[3] & 0xFF);
\r
2291 pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
\r
2294 tmp = (sd_status[4] & 0xFF);
\r
2295 pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
\r
2298 tmp = (sd_status[5] & 0xFF);
\r
2299 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
\r
2302 tmp = (sd_status[6] & 0xFF);
\r
2303 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
\r
2306 tmp = (sd_status[7] & 0xFF);
\r
2307 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
\r
2310 tmp = (sd_status[8] & 0xFF);
\r
2311 pCardStatus->SPEED_CLASS = (uint8_t)tmp;
\r
2314 tmp = (sd_status[9] & 0xFF);
\r
2315 pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
\r
2318 tmp = (sd_status[10] & 0xF0) >> 4;
\r
2319 pCardStatus->AU_SIZE = (uint8_t)tmp;
\r
2322 tmp = (sd_status[11] & 0xFF);
\r
2323 pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
\r
2326 tmp = (sd_status[12] & 0xFF);
\r
2327 pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
\r
2330 tmp = (sd_status[13] & 0xFC) >> 2;
\r
2331 pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
\r
2334 tmp = (sd_status[13] & 0x3);
\r
2335 pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
\r
2337 return errorstate;
\r
2348 /* Private function ----------------------------------------------------------*/
\r
2349 /** @addtogroup SD_Private_Functions
\r
2354 * @brief SD DMA transfer complete Rx callback.
\r
2355 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
2356 * the configuration information for the specified DMA module.
\r
2359 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
\r
2361 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
2363 /* DMA transfer is complete */
\r
2364 hsd->DmaTransferCplt = 1;
\r
2366 // /* Wait until SD transfer is complete */
\r
2367 // while(hsd->SdTransferCplt == 0)
\r
2371 // /* Disable the DMA channel */
\r
2372 // HAL_DMA_Abort(hdma);
\r
2374 /* Transfer complete user callback */
\r
2375 HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
\r
2379 * @brief SD DMA transfer Error Rx callback.
\r
2380 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
2381 * the configuration information for the specified DMA module.
\r
2384 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
\r
2386 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
2388 /* Transfer complete user callback */
\r
2389 HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
\r
2393 * @brief SD DMA transfer complete Tx callback.
\r
2394 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
2395 * the configuration information for the specified DMA module.
\r
2398 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
\r
2400 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
2402 /* DMA transfer is complete */
\r
2403 hsd->DmaTransferCplt = 1;
\r
2405 // /* Wait until SD transfer is complete */
\r
2406 // while(hsd->SdTransferCplt == 0)
\r
2410 // /* Disable the DMA channel */
\r
2411 // HAL_DMA_Abort(hdma);
\r
2413 /* Transfer complete user callback */
\r
2414 HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
\r
2418 * @brief SD DMA transfer Error Tx callback.
\r
2419 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
\r
2420 * the configuration information for the specified DMA module.
\r
2423 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
\r
2425 SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\r
2427 /* Transfer complete user callback */
\r
2428 HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
\r
2432 * @brief Returns the SD current state.
\r
2433 * @param hsd: SD handle
\r
2434 * @retval SD card current state
\r
2436 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
\r
2438 uint32_t resp1 = 0;
\r
2440 if (SD_SendStatus(hsd, &resp1) != SD_OK)
\r
2442 return SD_CARD_ERROR;
\r
2446 return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
\r
2451 * @brief Initializes all cards or single card as the case may be Card(s) come
\r
2452 * into standby state.
\r
2453 * @param hsd: SD handle
\r
2454 * @retval SD Card error state
\r
2456 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
\r
2458 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
2459 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2460 uint16_t sd_rca = 1;
\r
2462 if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
\r
2464 errorstate = SD_REQUEST_NOT_APPLICABLE;
\r
2466 return errorstate;
\r
2469 if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
\r
2471 /* Send CMD2 ALL_SEND_CID */
\r
2472 sdmmc_cmdinitstructure.Argument = 0;
\r
2473 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_ALL_SEND_CID;
\r
2474 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
\r
2475 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2476 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
2477 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2479 /* Check for error conditions */
\r
2480 errorstate = SD_CmdResp2Error(hsd);
\r
2482 if(errorstate != SD_OK)
\r
2484 return errorstate;
\r
2487 /* Get Card identification number data */
\r
2488 hsd->CID[0] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
\r
2489 hsd->CID[1] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
\r
2490 hsd->CID[2] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
\r
2491 hsd->CID[3] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
\r
2494 if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
\r
2495 (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
\r
2497 /* Send CMD3 SET_REL_ADDR with argument 0 */
\r
2498 /* SD Card publishes its RCA. */
\r
2499 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_REL_ADDR;
\r
2500 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
2501 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2503 /* Check for error conditions */
\r
2504 errorstate = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
\r
2506 if(errorstate != SD_OK)
\r
2508 return errorstate;
\r
2512 if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
\r
2514 /* Get the SD card RCA */
\r
2515 hsd->RCA = sd_rca;
\r
2517 /* Send CMD9 SEND_CSD with argument as card's RCA */
\r
2518 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
2519 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEND_CSD;
\r
2520 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_LONG;
\r
2521 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2523 /* Check for error conditions */
\r
2524 errorstate = SD_CmdResp2Error(hsd);
\r
2526 if(errorstate != SD_OK)
\r
2528 return errorstate;
\r
2531 /* Get Card Specific Data */
\r
2532 hsd->CSD[0] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
\r
2533 hsd->CSD[1] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
\r
2534 hsd->CSD[2] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
\r
2535 hsd->CSD[3] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
\r
2538 /* All cards are initialized */
\r
2539 return errorstate;
\r
2543 * @brief Selects of Deselects the corresponding card.
\r
2544 * @param hsd: SD handle
\r
2545 * @param addr: Address of the card to be selected
\r
2546 * @retval SD Card error state
\r
2548 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
\r
2550 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
2551 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2553 /* Send CMD7 SDIO_SEL_DESEL_CARD */
\r
2554 sdmmc_cmdinitstructure.Argument = (uint32_t)addr;
\r
2555 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEL_DESEL_CARD;
\r
2556 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
2557 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2558 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
2559 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2561 /* Check for error conditions */
\r
2562 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
\r
2564 return errorstate;
\r
2568 * @brief Enquires cards about their operating voltage and configures clock
\r
2569 * controls and stores SD information that will be needed in future
\r
2570 * in the SD handle.
\r
2571 * @param hsd: SD handle
\r
2572 * @retval SD Card error state
\r
2574 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
\r
2576 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
2577 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2578 uint32_t response = 0, count = 0, validvoltage = 0;
\r
2579 uint32_t sdtype = SD_STD_CAPACITY;
\r
2581 /* Power ON Sequence -------------------------------------------------------*/
\r
2582 /* Disable SDMMC Clock */
\r
2583 __HAL_SD_SDIO_DISABLE(hsd);
\r
2585 /* Set Power State to ON */
\r
2586 SDIO_PowerState_ON(hsd->Instance);
\r
2588 /* 1ms: required power up waiting time before starting the SD initialization
\r
2592 /* Enable SDMMC Clock */
\r
2593 __HAL_SD_SDIO_ENABLE(hsd);
\r
2595 /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
\r
2596 /* No CMD response required */
\r
2597 sdmmc_cmdinitstructure.Argument = 0;
\r
2598 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_GO_IDLE_STATE;
\r
2599 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_NO;
\r
2600 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2601 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
2602 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2604 /* Check for error conditions */
\r
2605 errorstate = SD_CmdError(hsd);
\r
2607 if(errorstate != SD_OK)
\r
2609 /* CMD Response Timeout (wait for CMDSENT flag) */
\r
2610 return errorstate;
\r
2613 /* CMD8: SEND_IF_COND ------------------------------------------------------*/
\r
2614 /* Send CMD8 to verify SD card interface operating condition */
\r
2615 /* Argument: - [31:12]: Reserved (shall be set to '0')
\r
2616 - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
\r
2617 - [7:0]: Check Pattern (recommended 0xAA) */
\r
2618 /* CMD Response: R7 */
\r
2619 sdmmc_cmdinitstructure.Argument = SD_CHECK_PATTERN;
\r
2620 sdmmc_cmdinitstructure.CmdIndex = SD_SDIO_SEND_IF_COND;
\r
2621 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
2622 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2624 /* Check for error conditions */
\r
2625 errorstate = SD_CmdResp7Error(hsd);
\r
2627 if (errorstate == SD_OK)
\r
2630 FF_PRINTF( "It's a 2.0 card, check SDHC\n" );
\r
2631 hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
\r
2632 sdtype = SD_HIGH_CAPACITY;
\r
2636 sdmmc_cmdinitstructure.Argument = 0;
\r
2637 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
\r
2638 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2640 /* Check for error conditions */
\r
2641 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
2643 /* If errorstate is Command Timeout, it is a MMC card */
\r
2644 /* If errorstate is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
\r
2646 if(errorstate == SD_OK)
\r
2649 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
\r
2650 while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
\r
2653 /* SEND CMD55 APP_CMD with RCA as 0 */
\r
2654 sdmmc_cmdinitstructure.Argument = 0;
\r
2655 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
\r
2656 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
2657 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2658 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
2659 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2661 /* Check for error conditions */
\r
2662 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
2664 if(errorstate != SD_OK)
\r
2666 return errorstate;
\r
2670 sdmmc_cmdinitstructure.Argument = SD_VOLTAGE_WINDOW_SD | sdtype;
\r
2671 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_OP_COND;
\r
2672 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
2673 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2674 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
2675 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2677 /* Check for error conditions */
\r
2678 errorstate = SD_CmdResp3Error(hsd);
\r
2680 if(errorstate != SD_OK)
\r
2682 return errorstate;
\r
2685 /* Get command response */
\r
2686 response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
\r
2688 /* Get operating voltage*/
\r
2689 validvoltage = (((response >> 31) == 1) ? 1 : 0);
\r
2691 if( ( count == 0 ) || ( validvoltage != 0 ) )
\r
2693 FF_PRINTF("Voltage resp: %08x\n", response);
\r
2699 if(count >= SD_MAX_VOLT_TRIAL)
\r
2701 FF_PRINTF("Can not agree on Voltage\n");
\r
2702 errorstate = SD_INVALID_VOLTRANGE;
\r
2704 return errorstate;
\r
2707 if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
\r
2709 hsd->CardType = HIGH_CAPACITY_SD_CARD;
\r
2712 } /* else MMC Card */
\r
2714 return errorstate;
\r
2718 * @brief Turns the SDMMC output signals off.
\r
2719 * @param hsd: SD handle
\r
2720 * @retval SD Card error state
\r
2722 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
\r
2724 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2726 /* Set Power State to OFF */
\r
2727 SDIO_PowerState_OFF(hsd->Instance);
\r
2729 return errorstate;
\r
2733 * @brief Returns the current card's status.
\r
2734 * @param hsd: SD handle
\r
2735 * @param pCardStatus: pointer to the buffer that will contain the SD card
\r
2736 * status (Card Status register)
\r
2737 * @retval SD Card error state
\r
2739 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
\r
2741 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
2742 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2744 if(pCardStatus == NULL)
\r
2746 errorstate = SD_INVALID_PARAMETER;
\r
2748 return errorstate;
\r
2751 /* Send Status command */
\r
2752 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
2753 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
\r
2754 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
2755 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
2756 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
2757 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
2759 /* Check for error conditions */
\r
2760 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
\r
2762 if(errorstate != SD_OK)
\r
2764 return errorstate;
\r
2767 /* Get SD card status */
\r
2768 *pCardStatus = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
\r
2770 return errorstate;
\r
2774 * @brief Checks for error conditions for CMD0.
\r
2775 * @param hsd: SD handle
\r
2776 * @retval SD Card error state
\r
2778 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
\r
2780 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2781 // uint32_t timeout;
\r
2783 uint32_t ulStarted = xTaskGetTickCount( );
\r
2784 uint32_t ulMaxTime = 200;
\r
2785 BaseType_t xHadTimeout = pdFALSE;
\r
2787 // timeout = SDIO_CMD0TIMEOUT;
\r
2789 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
\r
2793 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
\r
2794 if( ( xTaskGetTickCount( ) - ulStarted ) >= ulMaxTime )
\r
2796 xHadTimeout = pdTRUE;
\r
2802 if( xHadTimeout != pdFALSE )
\r
2804 errorstate = SD_CMD_RSP_TIMEOUT;
\r
2805 return errorstate;
\r
2808 /* Clear all the static flags */
\r
2809 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2811 return errorstate;
\r
2815 * @brief Checks for error conditions for R7 response.
\r
2816 * @param hsd: SD handle
\r
2817 * @retval SD Card error state
\r
2819 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
\r
2821 HAL_SD_ErrorTypedef errorstate = SD_ERROR;
\r
2822 // uint32_t timeout = SDIO_CMD0TIMEOUT;
\r
2824 uint32_t ulStarted = xTaskGetTickCount( );
\r
2825 uint32_t ulMaxTime = 200;
\r
2826 BaseType_t xHadTimeout = pdFALSE;
\r
2828 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
\r
2832 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
\r
2833 if( ( xTaskGetTickCount( ) - ulStarted ) >= ulMaxTime )
\r
2835 xHadTimeout = pdTRUE;
\r
2840 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2842 if( xHadTimeout != pdFALSE || tmp)
\r
2844 /* Card is not V2.0 compliant or card does not support the set voltage range */
\r
2845 errorstate = SD_CMD_RSP_TIMEOUT;
\r
2847 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2849 return errorstate;
\r
2852 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
\r
2854 /* Card is SD V2.0 compliant */
\r
2855 errorstate = SD_OK;
\r
2857 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
\r
2859 return errorstate;
\r
2862 return errorstate;
\r
2866 * @brief Checks for error conditions for R1 response.
\r
2867 * @param hsd: SD handle
\r
2868 * @param SD_CMD: The sent command index
\r
2869 * @retval SD Card error state
\r
2871 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
\r
2873 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
2874 uint32_t response_r1;
\r
2875 uint32_t remaining_loops = 168000 * 50;
\r
2877 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
2879 if( ( --remaining_loops ) == 0 )
\r
2881 FF_PRINTF( "SD_CmdResp1Error: times out\n" );
\r
2886 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
2888 errorstate = SD_CMD_RSP_TIMEOUT;
\r
2890 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
2892 return errorstate;
\r
2894 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
2896 errorstate = SD_CMD_CRC_FAIL;
\r
2898 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
2900 return errorstate;
\r
2903 /* Check response received is of desired command */
\r
2904 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
\r
2906 errorstate = SD_ILLEGAL_CMD;
\r
2908 return errorstate;
\r
2911 /* Clear all the static flags */
\r
2912 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
2914 /* We have received response, retrieve it for analysis */
\r
2915 response_r1 = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
\r
2917 if((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
\r
2919 return errorstate;
\r
2922 if((response_r1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
\r
2924 return(SD_ADDR_OUT_OF_RANGE);
\r
2927 if((response_r1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
\r
2929 return(SD_ADDR_MISALIGNED);
\r
2932 if((response_r1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
\r
2934 return(SD_BLOCK_LEN_ERR);
\r
2937 if((response_r1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
\r
2939 return(SD_ERASE_SEQ_ERR);
\r
2942 if((response_r1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
\r
2944 return(SD_BAD_ERASE_PARAM);
\r
2947 if((response_r1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
\r
2949 return(SD_WRITE_PROT_VIOLATION);
\r
2952 if((response_r1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
\r
2954 return(SD_LOCK_UNLOCK_FAILED);
\r
2957 if((response_r1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
\r
2959 return(SD_COM_CRC_FAILED);
\r
2962 if((response_r1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
\r
2964 return(SD_ILLEGAL_CMD);
\r
2967 if((response_r1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
\r
2969 return(SD_CARD_ECC_FAILED);
\r
2972 if((response_r1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
\r
2974 return(SD_CC_ERROR);
\r
2977 if((response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
\r
2979 return(SD_GENERAL_UNKNOWN_ERROR);
\r
2982 if((response_r1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
\r
2984 return(SD_STREAM_READ_UNDERRUN);
\r
2987 if((response_r1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
\r
2989 return(SD_STREAM_WRITE_OVERRUN);
\r
2992 if((response_r1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
\r
2994 return(SD_CID_CSD_OVERWRITE);
\r
2997 if((response_r1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
\r
2999 return(SD_WP_ERASE_SKIP);
\r
3002 if((response_r1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
\r
3004 return(SD_CARD_ECC_DISABLED);
\r
3007 if((response_r1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
\r
3009 return(SD_ERASE_RESET);
\r
3012 if((response_r1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
\r
3014 return(SD_AKE_SEQ_ERROR);
\r
3017 return errorstate;
\r
3021 * @brief Checks for error conditions for R3 (OCR) response.
\r
3022 * @param hsd: SD handle
\r
3023 * @retval SD Card error state
\r
3025 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
\r
3027 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
3029 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
3033 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
3035 errorstate = SD_CMD_RSP_TIMEOUT;
\r
3037 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
3039 return errorstate;
\r
3042 /* Clear all the static flags */
\r
3043 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
3045 return errorstate;
\r
3049 * @brief Checks for error conditions for R2 (CID or CSD) response.
\r
3050 * @param hsd: SD handle
\r
3051 * @retval SD Card error state
\r
3053 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
\r
3055 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
3057 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
3061 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
3063 errorstate = SD_CMD_RSP_TIMEOUT;
\r
3065 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
3067 return errorstate;
\r
3069 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
3071 errorstate = SD_CMD_CRC_FAIL;
\r
3073 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
3075 return errorstate;
\r
3079 /* No error flag set */
\r
3082 /* Clear all the static flags */
\r
3083 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
3085 return errorstate;
\r
3089 * @brief Checks for error conditions for R6 (RCA) response.
\r
3090 * @param hsd: SD handle
\r
3091 * @param SD_CMD: The sent command index
\r
3092 * @param pRCA: Pointer to the variable that will contain the SD card relative
\r
3094 * @retval SD Card error state
\r
3096 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
\r
3098 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
3099 uint32_t response_r1;
\r
3101 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
3105 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
3107 errorstate = SD_CMD_RSP_TIMEOUT;
\r
3109 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
3111 return errorstate;
\r
3113 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
3115 errorstate = SD_CMD_CRC_FAIL;
\r
3117 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
3119 return errorstate;
\r
3123 /* No error flag set */
\r
3126 /* Check response received is of desired command */
\r
3127 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
\r
3129 FF_PRINTF( "RESPCMD[2] = %08x cmd = %02x\n", hsd->Instance->RESPCMD, SD_CMD );
\r
3130 errorstate = SD_ILLEGAL_CMD;
\r
3132 return errorstate;
\r
3135 /* Clear all the static flags */
\r
3136 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
3138 /* We have received response, retrieve it. */
\r
3139 response_r1 = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
\r
3141 if((response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
\r
3143 *pRCA = (uint16_t) (response_r1 >> 16);
\r
3145 return errorstate;
\r
3148 if((response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
\r
3150 return(SD_GENERAL_UNKNOWN_ERROR);
\r
3153 if((response_r1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
\r
3155 FF_PRINTF( "response_r1 = %08x cmd = %02x\n", hsd->Instance->RESPCMD, SD_R6_ILLEGAL_CMD );
\r
3156 return(SD_ILLEGAL_CMD);
\r
3159 if((response_r1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
\r
3161 return(SD_COM_CRC_FAILED);
\r
3164 return errorstate;
\r
3168 * @brief Enables the SDMMC wide bus mode.
\r
3169 * @param hsd: SD handle
\r
3170 * @retval SD Card error state
\r
3172 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
\r
3174 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
3175 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
3177 uint32_t scr[2] = {0, 0};
\r
3179 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
3181 errorstate = SD_LOCK_UNLOCK_FAILED;
\r
3183 return errorstate;
\r
3186 /* Get SCR Register */
\r
3187 errorstate = SD_FindSCR(hsd, scr);
\r
3189 if(errorstate != SD_OK)
\r
3191 return errorstate;
\r
3194 /* If requested card supports wide bus operation */
\r
3195 if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
\r
3197 /* Send CMD55 APP_CMD with argument as card's RCA.*/
\r
3198 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
3199 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
\r
3200 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
3201 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
3202 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
3203 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3205 /* Check for error conditions */
\r
3206 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
3208 if(errorstate != SD_OK)
\r
3210 return errorstate;
\r
3213 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
\r
3214 sdmmc_cmdinitstructure.Argument = 2;
\r
3215 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
\r
3216 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3218 /* Check for error conditions */
\r
3219 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
\r
3221 if(errorstate != SD_OK)
\r
3223 return errorstate;
\r
3226 return errorstate;
\r
3230 errorstate = SD_REQUEST_NOT_APPLICABLE;
\r
3232 return errorstate;
\r
3237 * @brief Disables the SDMMC wide bus mode.
\r
3238 * @param hsd: SD handle
\r
3239 * @retval SD Card error state
\r
3241 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd)
\r
3243 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
3244 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
3246 uint32_t scr[2] = {0, 0};
\r
3248 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
\r
3250 errorstate = SD_LOCK_UNLOCK_FAILED;
\r
3252 return errorstate;
\r
3255 /* Get SCR Register */
\r
3256 errorstate = SD_FindSCR(hsd, scr);
\r
3258 if(errorstate != SD_OK)
\r
3260 return errorstate;
\r
3263 /* If requested card supports 1 bit mode operation */
\r
3264 if((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
\r
3266 /* Send CMD55 APP_CMD with argument as card's RCA */
\r
3267 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
3268 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
\r
3269 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
3270 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
3271 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
3272 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3274 /* Check for error conditions */
\r
3275 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
3277 if(errorstate != SD_OK)
\r
3279 return errorstate;
\r
3282 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
\r
3283 sdmmc_cmdinitstructure.Argument = 0;
\r
3284 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
\r
3285 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3287 /* Check for error conditions */
\r
3288 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
\r
3290 if(errorstate != SD_OK)
\r
3292 return errorstate;
\r
3295 return errorstate;
\r
3299 errorstate = SD_REQUEST_NOT_APPLICABLE;
\r
3301 return errorstate;
\r
3307 * @brief Finds the SD card SCR register value.
\r
3308 * @param hsd: SD handle
\r
3309 * @param pSCR: pointer to the buffer that will contain the SCR value
\r
3310 * @retval SD Card error state
\r
3312 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
\r
3314 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
3315 SDIO_DataInitTypeDef sdmmc_datainitstructure;
\r
3316 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
3317 uint32_t index = 0;
\r
3318 uint32_t tempscr[2] = {0, 0};
\r
3320 /* Set Block Size To 8 Bytes */
\r
3321 /* Send CMD55 APP_CMD with argument as card's RCA */
\r
3322 sdmmc_cmdinitstructure.Argument = (uint32_t)8;
\r
3323 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
\r
3324 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
3325 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
3326 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
3327 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3329 /* Check for error conditions */
\r
3330 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
\r
3332 if(errorstate != SD_OK)
\r
3334 return errorstate;
\r
3337 /* Send CMD55 APP_CMD with argument as card's RCA */
\r
3338 sdmmc_cmdinitstructure.Argument = (uint32_t)((hsd->RCA) << 16);
\r
3339 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
\r
3340 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3342 /* Check for error conditions */
\r
3343 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
\r
3345 if(errorstate != SD_OK)
\r
3347 return errorstate;
\r
3349 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
\r
3350 sdmmc_datainitstructure.DataLength = 8;
\r
3351 sdmmc_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
\r
3352 sdmmc_datainitstructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
\r
3353 sdmmc_datainitstructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
\r
3354 sdmmc_datainitstructure.DPSM = SDIO_DPSM_ENABLE;
\r
3355 SDIO_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
\r
3357 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
\r
3358 sdmmc_cmdinitstructure.Argument = 0;
\r
3359 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_SEND_SCR;
\r
3360 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3362 /* Check for error conditions */
\r
3363 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_SEND_SCR);
\r
3365 if(errorstate != SD_OK)
\r
3367 return errorstate;
\r
3370 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
\r
3372 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
\r
3374 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
\r
3379 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
\r
3381 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
\r
3383 errorstate = SD_DATA_TIMEOUT;
\r
3385 return errorstate;
\r
3387 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
\r
3389 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
\r
3391 errorstate = SD_DATA_CRC_FAIL;
\r
3393 return errorstate;
\r
3395 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
\r
3397 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
\r
3399 errorstate = SD_RX_OVERRUN;
\r
3401 return errorstate;
\r
3405 /* No error flag set */
\r
3408 /* Clear all the static flags */
\r
3409 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
3411 *(pSCR + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) |\
\r
3412 ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
\r
3414 *(pSCR) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) |\
\r
3415 ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
\r
3417 return errorstate;
\r
3421 * @brief Checks if the SD card is in programming state.
\r
3422 * @param hsd: SD handle
\r
3423 * @param pStatus: pointer to the variable that will contain the SD card state
\r
3424 * @retval SD Card error state
\r
3426 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus)
\r
3428 SDIO_CmdInitTypeDef sdmmc_cmdinitstructure;
\r
3429 HAL_SD_ErrorTypedef errorstate = SD_OK;
\r
3430 __IO uint32_t responseR1 = 0;
\r
3432 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
\r
3433 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
\r
3434 sdmmc_cmdinitstructure.Response = SDIO_RESPONSE_SHORT;
\r
3435 sdmmc_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
\r
3436 sdmmc_cmdinitstructure.CPSM = SDIO_CPSM_ENABLE;
\r
3437 SDIO_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
\r
3439 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
\r
3443 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
\r
3445 errorstate = SD_CMD_RSP_TIMEOUT;
\r
3447 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
\r
3449 return errorstate;
\r
3451 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
\r
3453 errorstate = SD_CMD_CRC_FAIL;
\r
3455 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
\r
3457 return errorstate;
\r
3461 /* No error flag set */
\r
3464 /* Check response received is of desired command */
\r
3465 if((uint32_t)SDIO_GetCommandResponse(hsd->Instance) != SD_CMD_SEND_STATUS)
\r
3467 FF_PRINTF( "RESPCMD[3] = %08x cmd = %02x\n", hsd->Instance->RESPCMD, SD_CMD_SEND_STATUS );
\r
3468 errorstate = SD_ILLEGAL_CMD;
\r
3470 return errorstate;
\r
3473 /* Clear all the static flags */
\r
3474 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
\r
3477 /* We have received response, retrieve it for analysis */
\r
3478 responseR1 = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
\r
3480 /* Find out card status */
\r
3481 *pStatus = (uint8_t)((responseR1 >> 9) & 0x0000000F);
\r
3483 if((responseR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
\r
3485 return errorstate;
\r
3488 if((responseR1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
\r
3490 return(SD_ADDR_OUT_OF_RANGE);
\r
3493 if((responseR1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
\r
3495 return(SD_ADDR_MISALIGNED);
\r
3498 if((responseR1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
\r
3500 return(SD_BLOCK_LEN_ERR);
\r
3503 if((responseR1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
\r
3505 return(SD_ERASE_SEQ_ERR);
\r
3508 if((responseR1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
\r
3510 return(SD_BAD_ERASE_PARAM);
\r
3513 if((responseR1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
\r
3515 return(SD_WRITE_PROT_VIOLATION);
\r
3518 if((responseR1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
\r
3520 return(SD_LOCK_UNLOCK_FAILED);
\r
3523 if((responseR1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
\r
3525 return(SD_COM_CRC_FAILED);
\r
3528 if((responseR1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
\r
3530 return(SD_ILLEGAL_CMD);
\r
3533 if((responseR1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
\r
3535 return(SD_CARD_ECC_FAILED);
\r
3538 if((responseR1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
\r
3540 return(SD_CC_ERROR);
\r
3543 if((responseR1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
\r
3545 return(SD_GENERAL_UNKNOWN_ERROR);
\r
3548 if((responseR1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
\r
3550 return(SD_STREAM_READ_UNDERRUN);
\r
3553 if((responseR1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
\r
3555 return(SD_STREAM_WRITE_OVERRUN);
\r
3558 if((responseR1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
\r
3560 return(SD_CID_CSD_OVERWRITE);
\r
3563 if((responseR1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
\r
3565 return(SD_WP_ERASE_SKIP);
\r
3568 if((responseR1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
\r
3570 return(SD_CARD_ECC_DISABLED);
\r
3573 if((responseR1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
\r
3575 return(SD_ERASE_RESET);
\r
3578 if((responseR1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
\r
3580 return(SD_AKE_SEQ_ERROR);
\r
3583 return errorstate;
\r
3590 #endif /* HAL_SD_MODULE_ENABLED */
\r
3600 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
\r
projects / freertos / blob