?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Create release.yml
[betaflight.git] / lib / main / STM32H7 / Drivers / STM32H7xx_HAL_Driver / Src / stm32h7xx_hal_sd.c
blobb2467ca30f5fd283bff0d8b5cf068a3713b00488
1 /**
2 ******************************************************************************
3 * @file stm32h7xx_hal_sd.c
4 * @author MCD Application Team
5 * @brief SD card HAL module driver.
6 * This file provides firmware functions to manage the following
7 * functionalities of the Secure Digital (SD) peripheral:
8 * + Initialization and de-initialization functions
9 * + IO operation functions
10 * + Peripheral Control functions
11 * + Peripheral State functions
12 *
13 @verbatim
14 ==============================================================================
15 ##### How to use this driver #####
16 ==============================================================================
17 [..]
18 This driver implements a high level communication layer for read and write from/to
19 this memory. The needed STM32 hardware resources (SDMMC and GPIO) are performed by
20 the user in HAL_SD_MspInit() function (MSP layer).
21 Basically, the MSP layer configuration should be the same as we provide in the
22 examples.
23 You can easily tailor this configuration according to hardware resources.
24
25 [..]
26 This driver is a generic layered driver for SDMMC memories which uses the HAL
27 SDMMC driver functions to interface with SD and uSD cards devices.
28 It is used as follows:
29
30 (#)Initialize the SDMMC low level resources by implementing the HAL_SD_MspInit() API:
31 (##) Enable the SDMMC interface clock using __HAL_RCC_SDMMC_CLK_ENABLE();
32 (##) SDMMC pins configuration for SD card
33 (+++) Enable the clock for the SDMMC GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
34 (+++) Configure these SDMMC pins as alternate function pull-up using HAL_GPIO_Init()
35 and according to your pin assignment;
36 (##) NVIC configuration if you need to use interrupt process (HAL_SD_ReadBlocks_IT()
37 and HAL_SD_WriteBlocks_IT() APIs).
38 (+++) Configure the SDMMC interrupt priorities using function HAL_NVIC_SetPriority();
39 (+++) Enable the NVIC SDMMC IRQs using function HAL_NVIC_EnableIRQ()
40 (+++) SDMMC interrupts are managed using the macros __HAL_SD_ENABLE_IT()
41 and __HAL_SD_DISABLE_IT() inside the communication process.
42 (+++) SDMMC interrupts pending bits are managed using the macros __HAL_SD_GET_IT()
43 and __HAL_SD_CLEAR_IT()
44 (##) No general propose DMA Configuration is needed, an Internal DMA for SDMMC Peripheral are used.
45
46 (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
47
48
49 *** SD Card Initialization and configuration ***
50 ================================================
51 [..]
52 To initialize the SD Card, use the HAL_SD_Init() function. It Initializes
53 SDMMC Peripheral(STM32 side) and the SD Card, and put it into StandBy State (Ready for data transfer).
54 This function provide the following operations:
55
56 (#) Apply the SD Card initialization process at 400KHz and check the SD Card
57 type (Standard Capacity or High Capacity). You can change or adapt this
58 frequency by adjusting the "ClockDiv" field.
59 The SD Card frequency (SDMMC_CK) is computed as follows:
60
61 SDMMC_CK = SDMMCCLK / (2 * ClockDiv)
62
63 In initialization mode and according to the SD Card standard,
64 make sure that the SDMMC_CK frequency doesn't exceed 400KHz.
65
66 This phase of initialization is done through SDMMC_Init() and
67 SDMMC_PowerState_ON() SDMMC low level APIs.
68
69 (#) Initialize the SD card. The API used is HAL_SD_InitCard().
70 This phase allows the card initialization and identification
71 and check the SD Card type (Standard Capacity or High Capacity)
72 The initialization flow is compatible with SD standard.
73
74 This API (HAL_SD_InitCard()) could be used also to reinitialize the card in case
75 of plug-off plug-in.
76
77 (#) Configure the SD Card Data transfer frequency. You can change or adapt this
78 frequency by adjusting the "ClockDiv" field.
79 In transfer mode and according to the SD Card standard, make sure that the
80 SDMMC_CK frequency doesn't exceed 25MHz and 100MHz in High-speed mode switch.
81
82 (#) Select the corresponding SD Card according to the address read with the step 2.
83
84 (#) Configure the SD Card in wide bus mode: 4-bits data.
85
86 *** SD Card Read operation ***
87 ==============================
88 [..]
89 (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
90 This function support only 512-bytes block length (the block size should be
91 chosen as 512 bytes).
92 You can choose either one block read operation or multiple block read operation
93 by adjusting the "NumberOfBlocks" parameter.
94 After this, you have to ensure that the transfer is done correctly. The check is done
95 through HAL_SD_GetCardState() function for SD card state.
96
97 (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
98 This function support only 512-bytes block length (the block size should be
99 chosen as 512 bytes).
100 You can choose either one block read operation or multiple block read operation
101 by adjusting the "NumberOfBlocks" parameter.
102 After this, you have to ensure that the transfer is done correctly. The check is done
103 through HAL_SD_GetCardState() function for SD card state.
104 You could also check the DMA transfer process through the SD Rx interrupt event.
105
106 (+) You can read from SD card in Interrupt mode by using function HAL_SD_ReadBlocks_IT().
107 This function support only 512-bytes block length (the block size should be
108 chosen as 512 bytes).
109 You can choose either one block read operation or multiple block read operation
110 by adjusting the "NumberOfBlocks" parameter.
111 After this, you have to ensure that the transfer is done correctly. The check is done
112 through HAL_SD_GetCardState() function for SD card state.
113 You could also check the IT transfer process through the SD Rx interrupt event.
114
115 *** SD Card Write operation ***
116 ===============================
117 [..]
118 (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
119 This function support only 512-bytes block length (the block size should be
120 chosen as 512 bytes).
121 You can choose either one block read operation or multiple block read operation
122 by adjusting the "NumberOfBlocks" parameter.
123 After this, you have to ensure that the transfer is done correctly. The check is done
124 through HAL_SD_GetCardState() function for SD card state.
125
126 (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
127 This function support only 512-bytes block length (the block size should be
128 chosen as 512 bytes).
129 You can choose either one block read operation or multiple block read operation
130 by adjusting the "NumberOfBlocks" parameter.
131 After this, you have to ensure that the transfer is done correctly. The check is done
132 through HAL_SD_GetCardState() function for SD card state.
133 You could also check the DMA transfer process through the SD Tx interrupt event.
134
135 (+) You can write to SD card in Interrupt mode by using function HAL_SD_WriteBlocks_IT().
136 This function support only 512-bytes block length (the block size should be
137 chosen as 512 bytes).
138 You can choose either one block read operation or multiple block read operation
139 by adjusting the "NumberOfBlocks" parameter.
140 After this, you have to ensure that the transfer is done correctly. The check is done
141 through HAL_SD_GetCardState() function for SD card state.
142 You could also check the IT transfer process through the SD Tx interrupt event.
143
144 *** SD card status ***
145 ======================
146 [..]
147 (+) The SD Status contains status bits that are related to the SD Memory
148 Card proprietary features. To get SD card status use the HAL_SD_GetCardStatus().
149
150 *** SD card information ***
151 ===========================
152 [..]
153 (+) To get SD card information, you can use the function HAL_SD_GetCardInfo().
154 It returns useful information about the SD card such as block size, card type,
155 block number ...
156
157 *** SD card CSD register ***
158 ============================
159 (+) The HAL_SD_GetCardCSD() API allows to get the parameters of the CSD register.
160 Some of the CSD parameters are useful for card initialization and identification.
161
162 *** SD card CID register ***
163 ============================
164 (+) The HAL_SD_GetCardCID() API allows to get the parameters of the CID register.
165 Some of the CSD parameters are useful for card initialization and identification.
166
167 *** SD HAL driver macros list ***
168 ==================================
169 [..]
170 Below the list of most used macros in SD HAL driver.
171
172 (+) __HAL_SD_ENABLE_IT: Enable the SD device interrupt
173 (+) __HAL_SD_DISABLE_IT: Disable the SD device interrupt
174 (+) __HAL_SD_GET_FLAG:Check whether the specified SD flag is set or not
175 (+) __HAL_SD_CLEAR_FLAG: Clear the SD's pending flags
176
177 (@) You can refer to the SD HAL driver header file for more useful macros
178
179 *** Callback registration ***
180 =============================================
181 [..]
182 The compilation define USE_HAL_SD_REGISTER_CALLBACKS when set to 1
183 allows the user to configure dynamically the driver callbacks.
184
185 Use Functions @ref HAL_SD_RegisterCallback() to register a user callback,
186 it allows to register following callbacks:
187 (+) TxCpltCallback : callback when a transmission transfer is completed.
188 (+) RxCpltCallback : callback when a reception transfer is completed.
189 (+) ErrorCallback : callback when error occurs.
190 (+) AbortCpltCallback : callback when abort is completed.
191 (+) Read_DMADblBuf0CpltCallback : callback when the DMA reception of first buffer is completed.
192 (+) Read_DMADblBuf1CpltCallback : callback when the DMA reception of second buffer is completed.
193 (+) Write_DMADblBuf0CpltCallback : callback when the DMA transmission of first buffer is completed.
194 (+) Write_DMADblBuf1CpltCallback : callback when the DMA transmission of second buffer is completed.
195 (+) MspInitCallback : SD MspInit.
196 (+) MspDeInitCallback : SD MspDeInit.
197 This function takes as parameters the HAL peripheral handle, the Callback ID
198 and a pointer to the user callback function.
199 For specific callbacks TransceiverCallback use dedicated register callbacks:
200 respectively @ref HAL_SD_RegisterTransceiverCallback().
201
202 Use function @ref HAL_SD_UnRegisterCallback() to reset a callback to the default
203 weak (surcharged) function. It allows to reset following callbacks:
204 (+) TxCpltCallback : callback when a transmission transfer is completed.
205 (+) RxCpltCallback : callback when a reception transfer is completed.
206 (+) ErrorCallback : callback when error occurs.
207 (+) AbortCpltCallback : callback when abort is completed.
208 (+) Read_DMADblBuf0CpltCallback : callback when the DMA reception of first buffer is completed.
209 (+) Read_DMADblBuf1CpltCallback : callback when the DMA reception of second buffer is completed.
210 (+) Write_DMADblBuf0CpltCallback : callback when the DMA transmission of first buffer is completed.
211 (+) Write_DMADblBuf1CpltCallback : callback when the DMA transmission of second buffer is completed.
212 (+) MspInitCallback : SD MspInit.
213 (+) MspDeInitCallback : SD MspDeInit.
214 This function) takes as parameters the HAL peripheral handle and the Callback ID.
215 For specific callbacks TransceiverCallback use dedicated unregister callbacks:
216 respectively @ref HAL_SD_UnRegisterTransceiverCallback().
217
218 By default, after the @ref HAL_SD_Init and if the state is HAL_SD_STATE_RESET
219 all callbacks are reset to the corresponding legacy weak (surcharged) functions.
220 Exception done for MspInit and MspDeInit callbacks that are respectively
221 reset to the legacy weak (surcharged) functions in the @ref HAL_SD_Init
222 and @ref HAL_SD_DeInit only when these callbacks are null (not registered beforehand).
223 If not, MspInit or MspDeInit are not null, the @ref HAL_SD_Init and @ref HAL_SD_DeInit
224 keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
225
226 Callbacks can be registered/unregistered in READY state only.
227 Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
228 in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
229 during the Init/DeInit.
230 In that case first register the MspInit/MspDeInit user callbacks
231 using @ref HAL_SD_RegisterCallback before calling @ref HAL_SD_DeInit
232 or @ref HAL_SD_Init function.
233
234 When The compilation define USE_HAL_SD_REGISTER_CALLBACKS is set to 0 or
235 not defined, the callback registering feature is not available
236 and weak (surcharged) callbacks are used.
237
238 @endverbatim
239 ******************************************************************************
240 * @attention
241 *
242 * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
243 * All rights reserved.</center></h2>
244 *
245 * This software component is licensed by ST under BSD 3-Clause license,
246 * the "License"; You may not use this file except in compliance with the
247 * License. You may obtain a copy of the License at:
248 * opensource.org/licenses/BSD-3-Clause
249 *
250 ******************************************************************************
251 */
252
253 /* Includes ------------------------------------------------------------------*/
254 #include "stm32h7xx_hal.h"
255
256 /** @addtogroup STM32H7xx_HAL_Driver
257 * @{
258 */
259
260 /** @addtogroup SD
261 * @{
262 */
263
264 #ifdef HAL_SD_MODULE_ENABLED
265
266 /* Private typedef -----------------------------------------------------------*/
267 /* Private define ------------------------------------------------------------*/
268 /** @addtogroup SD_Private_Defines
269 * @{
270 */
271
272 /**
273 * @}
274 */
275
276 /* Private macro -------------------------------------------------------------*/
277 #if defined (DLYB_SDMMC1) && defined (DLYB_SDMMC2)
278 #define SD_GET_DLYB_INSTANCE(SDMMC_INSTANCE) (((SDMMC_INSTANCE) == SDMMC1)? \
279 DLYB_SDMMC1 : DLYB_SDMMC2 )
280 #elif defined (DLYB_SDMMC1)
281 #define SD_GET_DLYB_INSTANCE(SDMMC_INSTANCE) ( DLYB_SDMMC1 )
282 #endif
283 /* Private variables ---------------------------------------------------------*/
284 /* Private function prototypes -----------------------------------------------*/
285 /* Private functions ---------------------------------------------------------*/
286 /** @defgroup SD_Private_Functions SD Private Functions
287 * @{
288 */
289 static uint32_t SD_InitCard (SD_HandleTypeDef *hsd);
290 static uint32_t SD_PowerON (SD_HandleTypeDef *hsd);
291 static uint32_t SD_SendSDStatus (SD_HandleTypeDef *hsd, uint32_t *pSDstatus);
292 static uint32_t SD_SendStatus (SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
293 static uint32_t SD_WideBus_Enable (SD_HandleTypeDef *hsd);
294 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd);
295 static uint32_t SD_FindSCR (SD_HandleTypeDef *hsd, uint32_t *pSCR);
296 static void SD_PowerOFF (SD_HandleTypeDef *hsd);
297 static void SD_Write_IT (SD_HandleTypeDef *hsd);
298 static void SD_Read_IT (SD_HandleTypeDef *hsd);
299 static uint32_t SD_HighSpeed (SD_HandleTypeDef *hsd);
300 #if (USE_SD_TRANSCEIVER != 0U)
301 static uint32_t SD_UltraHighSpeed (SD_HandleTypeDef *hsd);
302 static uint32_t SD_DDR_Mode (SD_HandleTypeDef *hsd);
303 #endif /* USE_SD_TRANSCEIVER */
304 /**
305 * @}
306 */
307
308 /* Exported functions --------------------------------------------------------*/
309 /** @addtogroup SD_Exported_Functions
310 * @{
311 */
312
313 /** @addtogroup SD_Exported_Functions_Group1
314 * @brief Initialization and de-initialization functions
315 *
316 @verbatim
317 ==============================================================================
318 ##### Initialization and de-initialization functions #####
319 ==============================================================================
320 [..]
321 This section provides functions allowing to initialize/de-initialize the SD
322 card device to be ready for use.
323
324 @endverbatim
325 * @{
326 */
327
328 /**
329 * @brief Initializes the SD according to the specified parameters in the
330 SD_HandleTypeDef and create the associated handle.
331 * @param hsd: Pointer to the SD handle
332 * @retval HAL status
333 */
334 HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
335 {
336 HAL_SD_CardStatusTypeDef CardStatus;
337 uint32_t speedgrade, unitsize;
338 uint32_t tickstart;
339
340 /* Check the SD handle allocation */
341 if(hsd == NULL)
342 {
343 return HAL_ERROR;
344 }
345
346 /* Check the parameters */
347 assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
348 assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));
349 assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
350 assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));
351 assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
352 assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));
353
354 if(hsd->State == HAL_SD_STATE_RESET)
355 {
356 /* Allocate lock resource and initialize it */
357 hsd->Lock = HAL_UNLOCKED;
358
359 #if (USE_SD_TRANSCEIVER != 0U)
360 /* Force SDMMC_TRANSCEIVER_PRESENT for Legacy usage */
361 if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN)
362 {
363 hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT;
364 }
365 #endif
366 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
367 /* Reset Callback pointers in HAL_SD_STATE_RESET only */
368 hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
369 hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
370 hsd->ErrorCallback = HAL_SD_ErrorCallback;
371 hsd->AbortCpltCallback = HAL_SD_AbortCallback;
372 hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;
373 hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;
374 hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;
375 hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;
376 #if (USE_SD_TRANSCEIVER != 0U)
377 if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
378 {
379 hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
380 }
381 #endif /* USE_SD_TRANSCEIVER */
382
383 if(hsd->MspInitCallback == NULL)
384 {
385 hsd->MspInitCallback = HAL_SD_MspInit;
386 }
387
388 /* Init the low level hardware */
389 hsd->MspInitCallback(hsd);
390 #else
391 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
392 HAL_SD_MspInit(hsd);
393 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
394 }
395
396 hsd->State = HAL_SD_STATE_BUSY;
397
398 /* Initialize the Card parameters */
399 if (HAL_SD_InitCard(hsd) != HAL_OK)
400 {
401 return HAL_ERROR;
402 }
403
404 if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK)
405 {
406 return HAL_ERROR;
407 }
408 /* Get Initial Card Speed from Card Status*/
409 speedgrade = CardStatus.UhsSpeedGrade;
410 unitsize = CardStatus.UhsAllocationUnitSize;
411 if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))
412 {
413 hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
414 }
415 else
416 {
417 if (hsd->SdCard.CardType == CARD_SDHC_SDXC)
418 {
419 hsd->SdCard.CardSpeed = CARD_HIGH_SPEED;
420 }
421 else
422 {
423 hsd->SdCard.CardSpeed = CARD_NORMAL_SPEED;
424 }
425
426 }
427 /* Configure the bus wide */
428 if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
429 {
430 return HAL_ERROR;
431 }
432
433 /* Verify that SD card is ready to use after Initialization */
434 tickstart = HAL_GetTick();
435 while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
436 {
437 if((HAL_GetTick()-tickstart) >= SDMMC_DATATIMEOUT)
438 {
439 hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
440 hsd->State= HAL_SD_STATE_READY;
441 return HAL_TIMEOUT;
442 }
443 }
444
445 /* Initialize the error code */
446 hsd->ErrorCode = HAL_SD_ERROR_NONE;
447
448 /* Initialize the SD operation */
449 hsd->Context = SD_CONTEXT_NONE;
450
451 /* Initialize the SD state */
452 hsd->State = HAL_SD_STATE_READY;
453
454 return HAL_OK;
455 }
456
457 /**
458 * @brief Initializes the SD Card.
459 * @param hsd: Pointer to SD handle
460 * @note This function initializes the SD card. It could be used when a card
461 re-initialization is needed.
462 * @retval HAL status
463 */
464 HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
465 {
466 uint32_t errorstate;
467 SD_InitTypeDef Init;
468 uint32_t sdmmc_clk;
469
470 /* Default SDMMC peripheral configuration for SD card initialization */
471 Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
472 Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
473 Init.BusWide = SDMMC_BUS_WIDE_1B;
474 Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
475
476 /* Init Clock should be less or equal to 400Khz*/
477 sdmmc_clk = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SDMMC);
478 Init.ClockDiv = sdmmc_clk/(2U*400000U);
479
480 #if (USE_SD_TRANSCEIVER != 0U)
481 if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
482 {
483 /* Set Transceiver polarity */
484 hsd->Instance->POWER |= SDMMC_POWER_DIRPOL;
485 }
486 #elif defined (USE_SD_DIRPOL)
487 /* Set Transceiver polarity */
488 hsd->Instance->POWER |= SDMMC_POWER_DIRPOL;
489 #endif /* USE_SD_TRANSCEIVER */
490
491 /* Initialize SDMMC peripheral interface with default configuration */
492 (void)SDMMC_Init(hsd->Instance, Init);
493
494 /* Set Power State to ON */
495 (void)SDMMC_PowerState_ON(hsd->Instance);
496
497 /* wait 74 Cycles: required power up waiting time before starting
498 the SD initialization sequence */
499 sdmmc_clk = sdmmc_clk/(2U*Init.ClockDiv);
500
501 if(sdmmc_clk != 0U)
502 {
503 HAL_Delay(1U+ (74U*1000U/(sdmmc_clk)));
504 }
505 else
506 {
507 HAL_Delay(2U);
508 }
509
510 /* Identify card operating voltage */
511 errorstate = SD_PowerON(hsd);
512 if(errorstate != HAL_SD_ERROR_NONE)
513 {
514 hsd->State = HAL_SD_STATE_READY;
515 hsd->ErrorCode |= errorstate;
516 return HAL_ERROR;
517 }
518
519 /* Card initialization */
520 errorstate = SD_InitCard(hsd);
521 if(errorstate != HAL_SD_ERROR_NONE)
522 {
523 hsd->State = HAL_SD_STATE_READY;
524 hsd->ErrorCode |= errorstate;
525 return HAL_ERROR;
526 }
527
528 /* Set Block Size for Card */
529 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
530 if(errorstate != HAL_SD_ERROR_NONE)
531 {
532 /* Clear all the static flags */
533 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
534 hsd->ErrorCode |= errorstate;
535 hsd->State = HAL_SD_STATE_READY;
536 return HAL_ERROR;
537 }
538
539 return HAL_OK;
540 }
541
542 /**
543 * @brief De-Initializes the SD card.
544 * @param hsd: Pointer to SD handle
545 * @retval HAL status
546 */
547 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
548 {
549 /* Check the SD handle allocation */
550 if(hsd == NULL)
551 {
552 return HAL_ERROR;
553 }
554
555 /* Check the parameters */
556 assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
557
558 hsd->State = HAL_SD_STATE_BUSY;
559
560 #if (USE_SD_TRANSCEIVER != 0U)
561 /* Desactivate the 1.8V Mode */
562 if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
563 {
564 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
565 if(hsd->DriveTransceiver_1_8V_Callback == NULL)
566 {
567 hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
568 }
569 hsd->DriveTransceiver_1_8V_Callback(RESET);
570 #else
571 HAL_SD_DriveTransceiver_1_8V_Callback(RESET);
572 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
573 }
574 #endif /* USE_SD_TRANSCEIVER */
575
576 /* Set SD power state to off */
577 SD_PowerOFF(hsd);
578
579 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
580 if(hsd->MspDeInitCallback == NULL)
581 {
582 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
583 }
584
585 /* DeInit the low level hardware */
586 hsd->MspDeInitCallback(hsd);
587 #else
588 /* De-Initialize the MSP layer */
589 HAL_SD_MspDeInit(hsd);
590 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
591
592 hsd->ErrorCode = HAL_SD_ERROR_NONE;
593 hsd->State = HAL_SD_STATE_RESET;
594
595 return HAL_OK;
596 }
597
598
599 /**
600 * @brief Initializes the SD MSP.
601 * @param hsd: Pointer to SD handle
602 * @retval None
603 */
604 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
605 {
606 /* Prevent unused argument(s) compilation warning */
607 UNUSED(hsd);
608
609 /* NOTE : This function should not be modified, when the callback is needed,
610 the HAL_SD_MspInit could be implemented in the user file
611 */
612 }
613
614 /**
615 * @brief De-Initialize SD MSP.
616 * @param hsd: Pointer to SD handle
617 * @retval None
618 */
619 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
620 {
621 /* Prevent unused argument(s) compilation warning */
622 UNUSED(hsd);
623
624 /* NOTE : This function should not be modified, when the callback is needed,
625 the HAL_SD_MspDeInit could be implemented in the user file
626 */
627 }
628
629 /**
630 * @}
631 */
632
633 /** @addtogroup SD_Exported_Functions_Group2
634 * @brief Data transfer functions
635 *
636 @verbatim
637 ==============================================================================
638 ##### IO operation functions #####
639 ==============================================================================
640 [..]
641 This subsection provides a set of functions allowing to manage the data
642 transfer from/to SD card.
643
644 @endverbatim
645 * @{
646 */
647
648 /**
649 * @brief Reads block(s) from a specified address in a card. The Data transfer
650 * is managed by polling mode.
651 * @note This API should be followed by a check on the card state through
652 * HAL_SD_GetCardState().
653 * @param hsd: Pointer to SD handle
654 * @param pData: pointer to the buffer that will contain the received data
655 * @param BlockAdd: Block Address from where data is to be read
656 * @param NumberOfBlocks: Number of SD blocks to read
657 * @param Timeout: Specify timeout value
658 * @retval HAL status
659 */
660 HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
661 {
662 SDMMC_DataInitTypeDef config;
663 uint32_t errorstate;
664 uint32_t tickstart = HAL_GetTick();
665 uint32_t count, data, dataremaining;
666 uint32_t add = BlockAdd;
667 uint8_t *tempbuff = pData;
668
669 if(NULL == pData)
670 {
671 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
672 return HAL_ERROR;
673 }
674
675 if(hsd->State == HAL_SD_STATE_READY)
676 {
677 hsd->ErrorCode = HAL_SD_ERROR_NONE;
678
679 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
680 {
681 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
682 return HAL_ERROR;
683 }
684
685 hsd->State = HAL_SD_STATE_BUSY;
686
687 /* Initialize data control register */
688 hsd->Instance->DCTRL = 0U;
689
690 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
691 {
692 add *= 512U;
693 }
694
695 /* Configure the SD DPSM (Data Path State Machine) */
696 config.DataTimeOut = SDMMC_DATATIMEOUT;
697 config.DataLength = NumberOfBlocks * BLOCKSIZE;
698 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
699 config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
700 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
701 config.DPSM = SDMMC_DPSM_DISABLE;
702 (void)SDMMC_ConfigData(hsd->Instance, &config);
703 __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
704
705 /* Read block(s) in polling mode */
706 if(NumberOfBlocks > 1U)
707 {
708 hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
709
710 /* Read Multi Block command */
711 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
712 }
713 else
714 {
715 hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
716
717 /* Read Single Block command */
718 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
719 }
720 if(errorstate != HAL_SD_ERROR_NONE)
721 {
722 /* Clear all the static flags */
723 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
724 hsd->ErrorCode |= errorstate;
725 hsd->State = HAL_SD_STATE_READY;
726 hsd->Context = SD_CONTEXT_NONE;
727 return HAL_ERROR;
728 }
729
730 /* Poll on SDMMC flags */
731 dataremaining = config.DataLength;
732 while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
733 {
734 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= 32U))
735 {
736 /* Read data from SDMMC Rx FIFO */
737 for(count = 0U; count < 8U; count++)
738 {
739 data = SDMMC_ReadFIFO(hsd->Instance);
740 *tempbuff = (uint8_t)(data & 0xFFU);
741 tempbuff++;
742 *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
743 tempbuff++;
744 *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
745 tempbuff++;
746 *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
747 tempbuff++;
748 }
749 dataremaining -= 32U;
750 }
751
752 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
753 {
754 /* Clear all the static flags */
755 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
756 hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
757 hsd->State= HAL_SD_STATE_READY;
758 hsd->Context = SD_CONTEXT_NONE;
759 return HAL_TIMEOUT;
760 }
761 }
762 __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
763
764 /* Send stop transmission command in case of multiblock read */
765 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
766 {
767 if(hsd->SdCard.CardType != CARD_SECURED)
768 {
769 /* Send stop transmission command */
770 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
771 if(errorstate != HAL_SD_ERROR_NONE)
772 {
773 /* Clear all the static flags */
774 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
775 hsd->ErrorCode |= errorstate;
776 hsd->State = HAL_SD_STATE_READY;
777 hsd->Context = SD_CONTEXT_NONE;
778 return HAL_ERROR;
779 }
780 }
781 }
782
783 /* Get error state */
784 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
785 {
786 /* Clear all the static flags */
787 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
788 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
789 hsd->State = HAL_SD_STATE_READY;
790 hsd->Context = SD_CONTEXT_NONE;
791 return HAL_ERROR;
792 }
793 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
794 {
795 /* Clear all the static flags */
796 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
797 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
798 hsd->State = HAL_SD_STATE_READY;
799 hsd->Context = SD_CONTEXT_NONE;
800 return HAL_ERROR;
801 }
802 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
803 {
804 /* Clear all the static flags */
805 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
806 hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
807 hsd->State = HAL_SD_STATE_READY;
808 hsd->Context = SD_CONTEXT_NONE;
809 return HAL_ERROR;
810 }
811 else
812 {
813 /* Nothing to do */
814 }
815
816 /* Clear all the static flags */
817 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
818
819 hsd->State = HAL_SD_STATE_READY;
820
821 return HAL_OK;
822 }
823 else
824 {
825 hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
826 return HAL_ERROR;
827 }
828 }
829
830 /**
831 * @brief Allows to write block(s) to a specified address in a card. The Data
832 * transfer is managed by polling mode.
833 * @note This API should be followed by a check on the card state through
834 * HAL_SD_GetCardState().
835 * @param hsd: Pointer to SD handle
836 * @param pData: pointer to the buffer that will contain the data to transmit
837 * @param BlockAdd: Block Address where data will be written
838 * @param NumberOfBlocks: Number of SD blocks to write
839 * @param Timeout: Specify timeout value
840 * @retval HAL status
841 */
842 HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
843 {
844 SDMMC_DataInitTypeDef config;
845 uint32_t errorstate;
846 uint32_t tickstart = HAL_GetTick();
847 uint32_t count, data, dataremaining;
848 uint32_t add = BlockAdd;
849 uint8_t *tempbuff = pData;
850
851 if(NULL == pData)
852 {
853 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
854 return HAL_ERROR;
855 }
856
857 if(hsd->State == HAL_SD_STATE_READY)
858 {
859 hsd->ErrorCode = HAL_SD_ERROR_NONE;
860
861 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
862 {
863 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
864 return HAL_ERROR;
865 }
866
867 hsd->State = HAL_SD_STATE_BUSY;
868
869 /* Initialize data control register */
870 hsd->Instance->DCTRL = 0U;
871
872 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
873 {
874 add *= 512U;
875 }
876
877 /* Configure the SD DPSM (Data Path State Machine) */
878 config.DataTimeOut = SDMMC_DATATIMEOUT;
879 config.DataLength = NumberOfBlocks * BLOCKSIZE;
880 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
881 config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
882 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
883 config.DPSM = SDMMC_DPSM_DISABLE;
884 (void)SDMMC_ConfigData(hsd->Instance, &config);
885 __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
886
887 /* Write Blocks in Polling mode */
888 if(NumberOfBlocks > 1U)
889 {
890 hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
891
892 /* Write Multi Block command */
893 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
894 }
895 else
896 {
897 hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
898
899 /* Write Single Block command */
900 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
901 }
902 if(errorstate != HAL_SD_ERROR_NONE)
903 {
904 /* Clear all the static flags */
905 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
906 hsd->ErrorCode |= errorstate;
907 hsd->State = HAL_SD_STATE_READY;
908 hsd->Context = SD_CONTEXT_NONE;
909 return HAL_ERROR;
910 }
911
912 /* Write block(s) in polling mode */
913 dataremaining = config.DataLength;
914 while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
915 {
916 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= 32U))
917 {
918 /* Write data to SDMMC Tx FIFO */
919 for(count = 0U; count < 8U; count++)
920 {
921 data = (uint32_t)(*tempbuff);
922 tempbuff++;
923 data |= ((uint32_t)(*tempbuff) << 8U);
924 tempbuff++;
925 data |= ((uint32_t)(*tempbuff) << 16U);
926 tempbuff++;
927 data |= ((uint32_t)(*tempbuff) << 24U);
928 tempbuff++;
929 (void)SDMMC_WriteFIFO(hsd->Instance, &data);
930 }
931 dataremaining -= 32U;
932 }
933
934 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
935 {
936 /* Clear all the static flags */
937 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
938 hsd->ErrorCode |= errorstate;
939 hsd->State = HAL_SD_STATE_READY;
940 hsd->Context = SD_CONTEXT_NONE;
941 return HAL_TIMEOUT;
942 }
943 }
944 __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
945
946 /* Send stop transmission command in case of multiblock write */
947 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
948 {
949 if(hsd->SdCard.CardType != CARD_SECURED)
950 {
951 /* Send stop transmission command */
952 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
953 if(errorstate != HAL_SD_ERROR_NONE)
954 {
955 /* Clear all the static flags */
956 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
957 hsd->ErrorCode |= errorstate;
958 hsd->State = HAL_SD_STATE_READY;
959 hsd->Context = SD_CONTEXT_NONE;
960 return HAL_ERROR;
961 }
962 }
963 }
964
965 /* Get error state */
966 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
967 {
968 /* Clear all the static flags */
969 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
970 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
971 hsd->State = HAL_SD_STATE_READY;
972 hsd->Context = SD_CONTEXT_NONE;
973 return HAL_ERROR;
974 }
975 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
976 {
977 /* Clear all the static flags */
978 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
979 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
980 hsd->State = HAL_SD_STATE_READY;
981 hsd->Context = SD_CONTEXT_NONE;
982 return HAL_ERROR;
983 }
984 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
985 {
986 /* Clear all the static flags */
987 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
988 hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
989 hsd->State = HAL_SD_STATE_READY;
990 hsd->Context = SD_CONTEXT_NONE;
991 return HAL_ERROR;
992 }
993 else
994 {
995 /* Nothing to do */
996 }
997
998 /* Clear all the static flags */
999 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
1000
1001 hsd->State = HAL_SD_STATE_READY;
1002
1003 return HAL_OK;
1004 }
1005 else
1006 {
1007 hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
1008 return HAL_ERROR;
1009 }
1010 }
1011
1012 /**
1013 * @brief Reads block(s) from a specified address in a card. The Data transfer
1014 * is managed in interrupt mode.
1015 * @note This API should be followed by a check on the card state through
1016 * HAL_SD_GetCardState().
1017 * @note You could also check the IT transfer process through the SD Rx
1018 * interrupt event.
1019 * @param hsd: Pointer to SD handle
1020 * @param pData: Pointer to the buffer that will contain the received data
1021 * @param BlockAdd: Block Address from where data is to be read
1022 * @param NumberOfBlocks: Number of blocks to read.
1023 * @retval HAL status
1024 */
1025 HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1026 {
1027 SDMMC_DataInitTypeDef config;
1028 uint32_t errorstate;
1029 uint32_t add = BlockAdd;
1030
1031 if(NULL == pData)
1032 {
1033 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1034 return HAL_ERROR;
1035 }
1036
1037 if(hsd->State == HAL_SD_STATE_READY)
1038 {
1039 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1040
1041 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1042 {
1043 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1044 return HAL_ERROR;
1045 }
1046
1047 hsd->State = HAL_SD_STATE_BUSY;
1048
1049 /* Initialize data control register */
1050 hsd->Instance->DCTRL = 0U;
1051
1052 hsd->pRxBuffPtr = pData;
1053 hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
1054
1055 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1056 {
1057 add *= 512U;
1058 }
1059
1060 /* Configure the SD DPSM (Data Path State Machine) */
1061 config.DataTimeOut = SDMMC_DATATIMEOUT;
1062 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1063 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1064 config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
1065 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1066 config.DPSM = SDMMC_DPSM_DISABLE;
1067 (void)SDMMC_ConfigData(hsd->Instance, &config);
1068 __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1069
1070 /* Read Blocks in IT mode */
1071 if(NumberOfBlocks > 1U)
1072 {
1073 hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);
1074
1075 /* Read Multi Block command */
1076 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1077 }
1078 else
1079 {
1080 hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);
1081
1082 /* Read Single Block command */
1083 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1084 }
1085 if(errorstate != HAL_SD_ERROR_NONE)
1086 {
1087 /* Clear all the static flags */
1088 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1089 hsd->ErrorCode |= errorstate;
1090 hsd->State = HAL_SD_STATE_READY;
1091 hsd->Context = SD_CONTEXT_NONE;
1092 return HAL_ERROR;
1093 }
1094
1095 __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND | SDMMC_FLAG_RXFIFOHF));
1096
1097 return HAL_OK;
1098 }
1099 else
1100 {
1101 return HAL_BUSY;
1102 }
1103 }
1104
1105 /**
1106 * @brief Writes block(s) to a specified address in a card. The Data transfer
1107 * is managed in interrupt mode.
1108 * @note This API should be followed by a check on the card state through
1109 * HAL_SD_GetCardState().
1110 * @note You could also check the IT transfer process through the SD Tx
1111 * interrupt event.
1112 * @param hsd: Pointer to SD handle
1113 * @param pData: Pointer to the buffer that will contain the data to transmit
1114 * @param BlockAdd: Block Address where data will be written
1115 * @param NumberOfBlocks: Number of blocks to write
1116 * @retval HAL status
1117 */
1118 HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1119 {
1120 SDMMC_DataInitTypeDef config;
1121 uint32_t errorstate;
1122 uint32_t add = BlockAdd;
1123
1124 if(NULL == pData)
1125 {
1126 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1127 return HAL_ERROR;
1128 }
1129
1130 if(hsd->State == HAL_SD_STATE_READY)
1131 {
1132 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1133
1134 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1135 {
1136 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1137 return HAL_ERROR;
1138 }
1139
1140 hsd->State = HAL_SD_STATE_BUSY;
1141
1142 /* Initialize data control register */
1143 hsd->Instance->DCTRL = 0U;
1144
1145 hsd->pTxBuffPtr = pData;
1146 hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
1147
1148 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1149 {
1150 add *= 512U;
1151 }
1152
1153 /* Configure the SD DPSM (Data Path State Machine) */
1154 config.DataTimeOut = SDMMC_DATATIMEOUT;
1155 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1156 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1157 config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
1158 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1159 config.DPSM = SDMMC_DPSM_DISABLE;
1160 (void)SDMMC_ConfigData(hsd->Instance, &config);
1161
1162 __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1163
1164 /* Write Blocks in Polling mode */
1165 if(NumberOfBlocks > 1U)
1166 {
1167 hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);
1168
1169 /* Write Multi Block command */
1170 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1171 }
1172 else
1173 {
1174 hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);
1175
1176 /* Write Single Block command */
1177 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1178 }
1179 if(errorstate != HAL_SD_ERROR_NONE)
1180 {
1181 /* Clear all the static flags */
1182 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1183 hsd->ErrorCode |= errorstate;
1184 hsd->State = HAL_SD_STATE_READY;
1185 hsd->Context = SD_CONTEXT_NONE;
1186 return HAL_ERROR;
1187 }
1188
1189 /* Enable transfer interrupts */
1190 __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND | SDMMC_FLAG_TXFIFOHE));
1191
1192 return HAL_OK;
1193 }
1194 else
1195 {
1196 return HAL_BUSY;
1197 }
1198 }
1199
1200 /**
1201 * @brief Reads block(s) from a specified address in a card. The Data transfer
1202 * is managed by DMA mode.
1203 * @note This API should be followed by a check on the card state through
1204 * HAL_SD_GetCardState().
1205 * @note You could also check the DMA transfer process through the SD Rx
1206 * interrupt event.
1207 * @param hsd: Pointer SD handle
1208 * @param pData: Pointer to the buffer that will contain the received data
1209 * @param BlockAdd: Block Address from where data is to be read
1210 * @param NumberOfBlocks: Number of blocks to read.
1211 * @retval HAL status
1212 */
1213 HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1214 {
1215 SDMMC_DataInitTypeDef config;
1216 uint32_t errorstate;
1217 uint32_t add = BlockAdd;
1218
1219 if(NULL == pData)
1220 {
1221 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1222 return HAL_ERROR;
1223 }
1224
1225 if(hsd->State == HAL_SD_STATE_READY)
1226 {
1227 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1228
1229 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1230 {
1231 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1232 return HAL_ERROR;
1233 }
1234
1235 hsd->State = HAL_SD_STATE_BUSY;
1236
1237 /* Initialize data control register */
1238 hsd->Instance->DCTRL = 0U;
1239
1240 hsd->pRxBuffPtr = pData;
1241 hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
1242
1243 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1244 {
1245 add *= 512U;
1246 }
1247
1248 /* Configure the SD DPSM (Data Path State Machine) */
1249 config.DataTimeOut = SDMMC_DATATIMEOUT;
1250 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1251 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1252 config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
1253 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1254 config.DPSM = SDMMC_DPSM_DISABLE;
1255 (void)SDMMC_ConfigData(hsd->Instance, &config);
1256
1257 __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1258 hsd->Instance->IDMABASE0 = (uint32_t) pData ;
1259 hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;
1260
1261 /* Read Blocks in DMA mode */
1262 if(NumberOfBlocks > 1U)
1263 {
1264 hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1265
1266 /* Read Multi Block command */
1267 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1268 }
1269 else
1270 {
1271 hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
1272
1273 /* Read Single Block command */
1274 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1275 }
1276 if(errorstate != HAL_SD_ERROR_NONE)
1277 {
1278 /* Clear all the static flags */
1279 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1280 hsd->ErrorCode |= errorstate;
1281 hsd->State = HAL_SD_STATE_READY;
1282 hsd->Context = SD_CONTEXT_NONE;
1283 return HAL_ERROR;
1284 }
1285
1286 /* Enable transfer interrupts */
1287 __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
1288
1289
1290 return HAL_OK;
1291 }
1292 else
1293 {
1294 return HAL_BUSY;
1295 }
1296 }
1297
1298 /**
1299 * @brief Writes block(s) to a specified address in a card. The Data transfer
1300 * is managed by DMA mode.
1301 * @note This API should be followed by a check on the card state through
1302 * HAL_SD_GetCardState().
1303 * @note You could also check the DMA transfer process through the SD Tx
1304 * interrupt event.
1305 * @param hsd: Pointer to SD handle
1306 * @param pData: Pointer to the buffer that will contain the data to transmit
1307 * @param BlockAdd: Block Address where data will be written
1308 * @param NumberOfBlocks: Number of blocks to write
1309 * @retval HAL status
1310 */
1311 HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1312 {
1313 SDMMC_DataInitTypeDef config;
1314 uint32_t errorstate;
1315 uint32_t add = BlockAdd;
1316
1317 if(NULL == pData)
1318 {
1319 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1320 return HAL_ERROR;
1321 }
1322
1323 if(hsd->State == HAL_SD_STATE_READY)
1324 {
1325 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1326
1327 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1328 {
1329 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1330 return HAL_ERROR;
1331 }
1332
1333 hsd->State = HAL_SD_STATE_BUSY;
1334
1335 /* Initialize data control register */
1336 hsd->Instance->DCTRL = 0U;
1337
1338 hsd->pTxBuffPtr = pData;
1339 hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
1340
1341 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1342 {
1343 add *= 512U;
1344 }
1345
1346 /* Configure the SD DPSM (Data Path State Machine) */
1347 config.DataTimeOut = SDMMC_DATATIMEOUT;
1348 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1349 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1350 config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
1351 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1352 config.DPSM = SDMMC_DPSM_DISABLE;
1353 (void)SDMMC_ConfigData(hsd->Instance, &config);
1354
1355
1356 __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1357
1358 hsd->Instance->IDMABASE0 = (uint32_t) pData ;
1359 hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;
1360
1361 /* Write Blocks in Polling mode */
1362 if(NumberOfBlocks > 1U)
1363 {
1364 hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1365
1366 /* Write Multi Block command */
1367 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1368 }
1369 else
1370 {
1371 hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
1372
1373 /* Write Single Block command */
1374 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1375 }
1376 if(errorstate != HAL_SD_ERROR_NONE)
1377 {
1378 /* Clear all the static flags */
1379 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1380 hsd->ErrorCode |= errorstate;
1381 hsd->State = HAL_SD_STATE_READY;
1382 hsd->Context = SD_CONTEXT_NONE;
1383 return HAL_ERROR;
1384 }
1385
1386 /* Enable transfer interrupts */
1387 __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));
1388
1389 return HAL_OK;
1390 }
1391 else
1392 {
1393 return HAL_BUSY;
1394 }
1395 }
1396
1397 /**
1398 * @brief Erases the specified memory area of the given SD card.
1399 * @note This API should be followed by a check on the card state through
1400 * HAL_SD_GetCardState().
1401 * @param hsd: Pointer to SD handle
1402 * @param BlockStartAdd: Start Block address
1403 * @param BlockEndAdd: End Block address
1404 * @retval HAL status
1405 */
1406 HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
1407 {
1408 uint32_t errorstate;
1409 uint32_t start_add = BlockStartAdd;
1410 uint32_t end_add = BlockEndAdd;
1411
1412 if(hsd->State == HAL_SD_STATE_READY)
1413 {
1414 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1415
1416 if(end_add < start_add)
1417 {
1418 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1419 return HAL_ERROR;
1420 }
1421
1422 if(end_add > (hsd->SdCard.LogBlockNbr))
1423 {
1424 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1425 return HAL_ERROR;
1426 }
1427
1428 hsd->State = HAL_SD_STATE_BUSY;
1429
1430 /* Check if the card command class supports erase command */
1431 if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
1432 {
1433 /* Clear all the static flags */
1434 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1435 hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
1436 hsd->State = HAL_SD_STATE_READY;
1437 return HAL_ERROR;
1438 }
1439
1440 if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
1441 {
1442 /* Clear all the static flags */
1443 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1444 hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
1445 hsd->State = HAL_SD_STATE_READY;
1446 return HAL_ERROR;
1447 }
1448
1449 /* Get start and end block for high capacity cards */
1450 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1451 {
1452 start_add *= 512U;
1453 end_add *= 512U;
1454 }
1455
1456 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1457 if(hsd->SdCard.CardType != CARD_SECURED)
1458 {
1459 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
1460 errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
1461 if(errorstate != HAL_SD_ERROR_NONE)
1462 {
1463 /* Clear all the static flags */
1464 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1465 hsd->ErrorCode |= errorstate;
1466 hsd->State = HAL_SD_STATE_READY;
1467 return HAL_ERROR;
1468 }
1469
1470 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
1471 errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
1472 if(errorstate != HAL_SD_ERROR_NONE)
1473 {
1474 /* Clear all the static flags */
1475 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1476 hsd->ErrorCode |= errorstate;
1477 hsd->State = HAL_SD_STATE_READY;
1478 return HAL_ERROR;
1479 }
1480 }
1481
1482 /* Send CMD38 ERASE */
1483 errorstate = SDMMC_CmdErase(hsd->Instance, 0UL);
1484 if(errorstate != HAL_SD_ERROR_NONE)
1485 {
1486 /* Clear all the static flags */
1487 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1488 hsd->ErrorCode |= errorstate;
1489 hsd->State = HAL_SD_STATE_READY;
1490 return HAL_ERROR;
1491 }
1492
1493 hsd->State = HAL_SD_STATE_READY;
1494
1495 return HAL_OK;
1496 }
1497 else
1498 {
1499 return HAL_BUSY;
1500 }
1501 }
1502
1503 /**
1504 * @brief This function handles SD card interrupt request.
1505 * @param hsd: Pointer to SD handle
1506 * @retval None
1507 */
1508 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1509 {
1510 uint32_t errorstate;
1511 uint32_t context = hsd->Context;
1512
1513 /* Check for SDMMC interrupt flags */
1514 if((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1515 {
1516 SD_Read_IT(hsd);
1517 }
1518
1519 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) != RESET)
1520 {
1521 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DATAEND);
1522
1523 __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT |\
1524 SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR | SDMMC_IT_TXFIFOHE |\
1525 SDMMC_IT_RXFIFOHF);
1526
1527 __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_IDMABTC);
1528 __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
1529
1530 if((context & SD_CONTEXT_IT) != 0U)
1531 {
1532 if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1533 {
1534 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1535 if(errorstate != HAL_SD_ERROR_NONE)
1536 {
1537 hsd->ErrorCode |= errorstate;
1538 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1539 hsd->ErrorCallback(hsd);
1540 #else
1541 HAL_SD_ErrorCallback(hsd);
1542 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1543 }
1544 }
1545
1546 /* Clear all the static flags */
1547 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
1548
1549 hsd->State = HAL_SD_STATE_READY;
1550 hsd->Context = SD_CONTEXT_NONE;
1551 if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1552 {
1553 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1554 hsd->RxCpltCallback(hsd);
1555 #else
1556 HAL_SD_RxCpltCallback(hsd);
1557 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1558 }
1559 else
1560 {
1561 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1562 hsd->TxCpltCallback(hsd);
1563 #else
1564 HAL_SD_TxCpltCallback(hsd);
1565 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1566 }
1567 }
1568 else if((context & SD_CONTEXT_DMA) != 0U)
1569 {
1570 hsd->Instance->DLEN = 0;
1571 hsd->Instance->DCTRL = 0;
1572 hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
1573
1574 /* Stop Transfer for Write Multi blocks or Read Multi blocks */
1575 if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1576 {
1577 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1578 if(errorstate != HAL_SD_ERROR_NONE)
1579 {
1580 hsd->ErrorCode |= errorstate;
1581 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1582 hsd->ErrorCallback(hsd);
1583 #else
1584 HAL_SD_ErrorCallback(hsd);
1585 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1586 }
1587 }
1588
1589 hsd->State = HAL_SD_STATE_READY;
1590 hsd->Context = SD_CONTEXT_NONE;
1591 if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1592 {
1593 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1594 hsd->TxCpltCallback(hsd);
1595 #else
1596 HAL_SD_TxCpltCallback(hsd);
1597 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1598 }
1599 if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1600 {
1601 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1602 hsd->RxCpltCallback(hsd);
1603 #else
1604 HAL_SD_RxCpltCallback(hsd);
1605 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1606 }
1607 }
1608 else
1609 {
1610 /* Nothing to do */
1611 }
1612 }
1613
1614 else if((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1615 {
1616 SD_Write_IT(hsd);
1617 }
1618
1619 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_RXOVERR | SDMMC_FLAG_TXUNDERR) != RESET)
1620 {
1621 /* Set Error code */
1622 if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_DCRCFAIL) != RESET)
1623 {
1624 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
1625 }
1626 if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_DTIMEOUT) != RESET)
1627 {
1628 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1629 }
1630 if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_RXOVERR) != RESET)
1631 {
1632 hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
1633 }
1634 if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_TXUNDERR) != RESET)
1635 {
1636 hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
1637 }
1638
1639 /* Clear All flags */
1640 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
1641
1642 /* Disable all interrupts */
1643 __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
1644 SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);
1645
1646 __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
1647 hsd->Instance->DCTRL |= SDMMC_DCTRL_FIFORST;
1648 hsd->Instance->CMD |= SDMMC_CMD_CMDSTOP;
1649 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
1650 hsd->Instance->CMD &= ~(SDMMC_CMD_CMDSTOP);
1651 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DABORT);
1652
1653 if((context & SD_CONTEXT_IT) != 0U)
1654 {
1655 /* Set the SD state to ready to be able to start again the process */
1656 hsd->State = HAL_SD_STATE_READY;
1657 hsd->Context = SD_CONTEXT_NONE;
1658 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1659 hsd->ErrorCallback(hsd);
1660 #else
1661 HAL_SD_ErrorCallback(hsd);
1662 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1663 }
1664 else if((context & SD_CONTEXT_DMA) != 0U)
1665 {
1666 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
1667 {
1668 /* Disable Internal DMA */
1669 __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_IDMABTC);
1670 hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
1671
1672 /* Set the SD state to ready to be able to start again the process */
1673 hsd->State = HAL_SD_STATE_READY;
1674 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1675 hsd->ErrorCallback(hsd);
1676 #else
1677 HAL_SD_ErrorCallback(hsd);
1678 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1679 }
1680 }
1681 else
1682 {
1683 /* Nothing to do */
1684 }
1685 }
1686
1687 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_IDMABTC) != RESET)
1688 {
1689 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_IDMABTC);
1690 if(READ_BIT(hsd->Instance->IDMACTRL, SDMMC_IDMA_IDMABACT) == 0U)
1691 {
1692 /* Current buffer is buffer0, Transfer complete for buffer1 */
1693 if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1694 {
1695 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1696 hsd->Write_DMADblBuf1CpltCallback(hsd);
1697 #else
1698 HAL_SDEx_Write_DMADoubleBuf1CpltCallback(hsd);
1699 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1700 }
1701 else /* SD_CONTEXT_READ_MULTIPLE_BLOCK */
1702 {
1703 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1704 hsd->Read_DMADblBuf1CpltCallback(hsd);
1705 #else
1706 HAL_SDEx_Read_DMADoubleBuf1CpltCallback(hsd);
1707 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1708 }
1709 }
1710 else /* SD_DMA_BUFFER1 */
1711 {
1712 /* Current buffer is buffer1, Transfer complete for buffer0 */
1713 if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1714 {
1715 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1716 hsd->Write_DMADblBuf0CpltCallback(hsd);
1717 #else
1718 HAL_SDEx_Write_DMADoubleBuf0CpltCallback(hsd);
1719 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1720 }
1721 else /* SD_CONTEXT_READ_MULTIPLE_BLOCK */
1722 {
1723 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1724 hsd->Read_DMADblBuf0CpltCallback(hsd);
1725 #else
1726 HAL_SDEx_Read_DMADoubleBuf0CpltCallback(hsd);
1727 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1728 }
1729 }
1730 }
1731 else
1732 {
1733 /* Nothing to do */
1734 }
1735 }
1736
1737 /**
1738 * @brief return the SD state
1739 * @param hsd: Pointer to sd handle
1740 * @retval HAL state
1741 */
1742 HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
1743 {
1744 return hsd->State;
1745 }
1746
1747 /**
1748 * @brief Return the SD error code
1749 * @param hsd : Pointer to a SD_HandleTypeDef structure that contains
1750 * the configuration information.
1751 * @retval SD Error Code
1752 */
1753 uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
1754 {
1755 return hsd->ErrorCode;
1756 }
1757
1758 /**
1759 * @brief Tx Transfer completed callbacks
1760 * @param hsd: Pointer to SD handle
1761 * @retval None
1762 */
1763 __weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
1764 {
1765 /* Prevent unused argument(s) compilation warning */
1766 UNUSED(hsd);
1767
1768 /* NOTE : This function should not be modified, when the callback is needed,
1769 the HAL_SD_TxCpltCallback can be implemented in the user file
1770 */
1771 }
1772
1773 /**
1774 * @brief Rx Transfer completed callbacks
1775 * @param hsd: Pointer SD handle
1776 * @retval None
1777 */
1778 __weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
1779 {
1780 /* Prevent unused argument(s) compilation warning */
1781 UNUSED(hsd);
1782
1783 /* NOTE : This function should not be modified, when the callback is needed,
1784 the HAL_SD_RxCpltCallback can be implemented in the user file
1785 */
1786 }
1787
1788 /**
1789 * @brief SD error callbacks
1790 * @param hsd: Pointer SD handle
1791 * @retval None
1792 */
1793 __weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
1794 {
1795 /* Prevent unused argument(s) compilation warning */
1796 UNUSED(hsd);
1797
1798 /* NOTE : This function should not be modified, when the callback is needed,
1799 the HAL_SD_ErrorCallback can be implemented in the user file
1800 */
1801 }
1802
1803 /**
1804 * @brief SD Abort callbacks
1805 * @param hsd: Pointer SD handle
1806 * @retval None
1807 */
1808 __weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
1809 {
1810 /* Prevent unused argument(s) compilation warning */
1811 UNUSED(hsd);
1812
1813 /* NOTE : This function should not be modified, when the callback is needed,
1814 the HAL_SD_AbortCallback can be implemented in the user file
1815 */
1816 }
1817
1818 #if (USE_SD_TRANSCEIVER != 0U)
1819 /**
1820 * @brief Enable/Disable the SD Transceiver 1.8V Mode Callback.
1821 * @param status: Voltage Switch State
1822 * @retval None
1823 */
1824 __weak void HAL_SD_DriveTransceiver_1_8V_Callback(FlagStatus status)
1825 {
1826 /* Prevent unused argument(s) compilation warning */
1827 UNUSED(status);
1828 /* NOTE : This function should not be modified, when the callback is needed,
1829 the HAL_SD_EnableTransceiver could be implemented in the user file
1830 */
1831 }
1832 #endif /* USE_SD_TRANSCEIVER */
1833
1834 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1835 /**
1836 * @brief Register a User SD Callback
1837 * To be used instead of the weak (surcharged) predefined callback
1838 * @param hsd : SD handle
1839 * @param CallbackID : ID of the callback to be registered
1840 * This parameter can be one of the following values:
1841 * @arg @ref HAL_SD_TX_CPLT_CB_ID SD Tx Complete Callback ID
1842 * @arg @ref HAL_SD_RX_CPLT_CB_ID SD Rx Complete Callback ID
1843 * @arg @ref HAL_SD_ERROR_CB_ID SD Error Callback ID
1844 * @arg @ref HAL_SD_ABORT_CB_ID SD Abort Callback ID
1845 * @arg @ref HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Rx Double buffer 0 Callback ID
1846 * @arg @ref HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Rx Double buffer 1 Callback ID
1847 * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Tx Double buffer 0 Callback ID
1848 * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Tx Double buffer 1 Callback ID
1849 * @arg @ref HAL_SD_MSP_INIT_CB_ID SD MspInit Callback ID
1850 * @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
1851 * @param pCallback : pointer to the Callback function
1852 * @retval status
1853 */
1854 HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
1855 {
1856 HAL_StatusTypeDef status = HAL_OK;
1857
1858 if(pCallback == NULL)
1859 {
1860 /* Update the error code */
1861 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1862 return HAL_ERROR;
1863 }
1864
1865 /* Process locked */
1866 __HAL_LOCK(hsd);
1867
1868 if(hsd->State == HAL_SD_STATE_READY)
1869 {
1870 switch (CallbackID)
1871 {
1872 case HAL_SD_TX_CPLT_CB_ID :
1873 hsd->TxCpltCallback = pCallback;
1874 break;
1875 case HAL_SD_RX_CPLT_CB_ID :
1876 hsd->RxCpltCallback = pCallback;
1877 break;
1878 case HAL_SD_ERROR_CB_ID :
1879 hsd->ErrorCallback = pCallback;
1880 break;
1881 case HAL_SD_ABORT_CB_ID :
1882 hsd->AbortCpltCallback = pCallback;
1883 break;
1884 case HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID :
1885 hsd->Read_DMADblBuf0CpltCallback = pCallback;
1886 break;
1887 case HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID :
1888 hsd->Read_DMADblBuf1CpltCallback = pCallback;
1889 break;
1890 case HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID :
1891 hsd->Write_DMADblBuf0CpltCallback = pCallback;
1892 break;
1893 case HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID :
1894 hsd->Write_DMADblBuf1CpltCallback = pCallback;
1895 break;
1896 case HAL_SD_MSP_INIT_CB_ID :
1897 hsd->MspInitCallback = pCallback;
1898 break;
1899 case HAL_SD_MSP_DEINIT_CB_ID :
1900 hsd->MspDeInitCallback = pCallback;
1901 break;
1902 default :
1903 /* Update the error code */
1904 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1905 /* update return status */
1906 status = HAL_ERROR;
1907 break;
1908 }
1909 }
1910 else if (hsd->State == HAL_SD_STATE_RESET)
1911 {
1912 switch (CallbackID)
1913 {
1914 case HAL_SD_MSP_INIT_CB_ID :
1915 hsd->MspInitCallback = pCallback;
1916 break;
1917 case HAL_SD_MSP_DEINIT_CB_ID :
1918 hsd->MspDeInitCallback = pCallback;
1919 break;
1920 default :
1921 /* Update the error code */
1922 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1923 /* update return status */
1924 status = HAL_ERROR;
1925 break;
1926 }
1927 }
1928 else
1929 {
1930 /* Update the error code */
1931 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1932 /* update return status */
1933 status = HAL_ERROR;
1934 }
1935
1936 /* Release Lock */
1937 __HAL_UNLOCK(hsd);
1938 return status;
1939 }
1940
1941 /**
1942 * @brief Unregister a User SD Callback
1943 * SD Callback is redirected to the weak (surcharged) predefined callback
1944 * @param hsd : SD handle
1945 * @param CallbackID : ID of the callback to be unregistered
1946 * This parameter can be one of the following values:
1947 * @arg @ref HAL_SD_TX_CPLT_CB_ID SD Tx Complete Callback ID
1948 * @arg @ref HAL_SD_RX_CPLT_CB_ID SD Rx Complete Callback ID
1949 * @arg @ref HAL_SD_ERROR_CB_ID SD Error Callback ID
1950 * @arg @ref HAL_SD_ABORT_CB_ID SD Abort Callback ID
1951 * @arg @ref HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Rx Double buffer 0 Callback ID
1952 * @arg @ref HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Rx Double buffer 1 Callback ID
1953 * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Tx Double buffer 0 Callback ID
1954 * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Tx Double buffer 1 Callback ID
1955 * @arg @ref HAL_SD_MSP_INIT_CB_ID SD MspInit Callback ID
1956 * @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
1957 * @retval status
1958 */
1959 HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
1960 {
1961 HAL_StatusTypeDef status = HAL_OK;
1962
1963 /* Process locked */
1964 __HAL_LOCK(hsd);
1965
1966 if(hsd->State == HAL_SD_STATE_READY)
1967 {
1968 switch (CallbackID)
1969 {
1970 case HAL_SD_TX_CPLT_CB_ID :
1971 hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
1972 break;
1973 case HAL_SD_RX_CPLT_CB_ID :
1974 hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
1975 break;
1976 case HAL_SD_ERROR_CB_ID :
1977 hsd->ErrorCallback = HAL_SD_ErrorCallback;
1978 break;
1979 case HAL_SD_ABORT_CB_ID :
1980 hsd->AbortCpltCallback = HAL_SD_AbortCallback;
1981 break;
1982 case HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID :
1983 hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;
1984 break;
1985 case HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID :
1986 hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;
1987 break;
1988 case HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID :
1989 hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;
1990 break;
1991 case HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID :
1992 hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;
1993 break;
1994 case HAL_SD_MSP_INIT_CB_ID :
1995 hsd->MspInitCallback = HAL_SD_MspInit;
1996 break;
1997 case HAL_SD_MSP_DEINIT_CB_ID :
1998 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
1999 break;
2000 default :
2001 /* Update the error code */
2002 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2003 /* update return status */
2004 status = HAL_ERROR;
2005 break;
2006 }
2007 }
2008 else if (hsd->State == HAL_SD_STATE_RESET)
2009 {
2010 switch (CallbackID)
2011 {
2012 case HAL_SD_MSP_INIT_CB_ID :
2013 hsd->MspInitCallback = HAL_SD_MspInit;
2014 break;
2015 case HAL_SD_MSP_DEINIT_CB_ID :
2016 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
2017 break;
2018 default :
2019 /* Update the error code */
2020 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2021 /* update return status */
2022 status = HAL_ERROR;
2023 break;
2024 }
2025 }
2026 else
2027 {
2028 /* Update the error code */
2029 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2030 /* update return status */
2031 status = HAL_ERROR;
2032 }
2033
2034 /* Release Lock */
2035 __HAL_UNLOCK(hsd);
2036 return status;
2037 }
2038
2039 #if (USE_SD_TRANSCEIVER != 0U)
2040 /**
2041 * @brief Register a User SD Transceiver Callback
2042 * To be used instead of the weak (surcharged) predefined callback
2043 * @param hsd : SD handle
2044 * @param pCallback : pointer to the Callback function
2045 * @retval status
2046 */
2047 HAL_StatusTypeDef HAL_SD_RegisterTransceiverCallback(SD_HandleTypeDef *hsd, pSD_TransceiverCallbackTypeDef pCallback)
2048 {
2049 HAL_StatusTypeDef status = HAL_OK;
2050
2051 if(pCallback == NULL)
2052 {
2053 /* Update the error code */
2054 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2055 return HAL_ERROR;
2056 }
2057
2058 /* Process locked */
2059 __HAL_LOCK(hsd);
2060
2061 if(hsd->State == HAL_SD_STATE_READY)
2062 {
2063 hsd->DriveTransceiver_1_8V_Callback = pCallback;
2064 }
2065 else
2066 {
2067 /* Update the error code */
2068 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2069 /* update return status */
2070 status = HAL_ERROR;
2071 }
2072
2073 /* Release Lock */
2074 __HAL_UNLOCK(hsd);
2075 return status;
2076 }
2077
2078 /**
2079 * @brief Unregister a User SD Transceiver Callback
2080 * SD Callback is redirected to the weak (surcharged) predefined callback
2081 * @param hsd : SD handle
2082 * @retval status
2083 */
2084 HAL_StatusTypeDef HAL_SD_UnRegisterTransceiverCallback(SD_HandleTypeDef *hsd)
2085 {
2086 HAL_StatusTypeDef status = HAL_OK;
2087
2088 /* Process locked */
2089 __HAL_LOCK(hsd);
2090
2091 if(hsd->State == HAL_SD_STATE_READY)
2092 {
2093 hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
2094 }
2095 else
2096 {
2097 /* Update the error code */
2098 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2099 /* update return status */
2100 status = HAL_ERROR;
2101 }
2102
2103 /* Release Lock */
2104 __HAL_UNLOCK(hsd);
2105 return status;
2106 }
2107 #endif /* USE_SD_TRANSCEIVER */
2108 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2109
2110 /**
2111 * @}
2112 */
2113
2114 /** @addtogroup SD_Exported_Functions_Group3
2115 * @brief management functions
2116 *
2117 @verbatim
2118 ==============================================================================
2119 ##### Peripheral Control functions #####
2120 ==============================================================================
2121 [..]
2122 This subsection provides a set of functions allowing to control the SD card
2123 operations and get the related information
2124
2125 @endverbatim
2126 * @{
2127 */
2128
2129 /**
2130 * @brief Returns information the information of the card which are stored on
2131 * the CID register.
2132 * @param hsd: Pointer to SD handle
2133 * @param pCID: Pointer to a HAL_SD_CardCIDTypeDef structure that
2134 * contains all CID register parameters
2135 * @retval HAL status
2136 */
2137 HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
2138 {
2139 pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U);
2140
2141 pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U);
2142
2143 pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U));
2144
2145 pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU);
2146
2147 pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U);
2148
2149 pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U));
2150
2151 pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U);
2152
2153 pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U);
2154
2155 pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U);
2156
2157 pCID->Reserved2 = 1U;
2158
2159 return HAL_OK;
2160 }
2161
2162 /**
2163 * @brief Returns information the information of the card which are stored on
2164 * the CSD register.
2165 * @param hsd: Pointer to SD handle
2166 * @param pCSD: Pointer to a HAL_SD_CardCSDTypeDef structure that
2167 * contains all CSD register parameters
2168 * @retval HAL status
2169 */
2170 HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
2171 {
2172 pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U);
2173
2174 pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U);
2175
2176 pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U);
2177
2178 pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U);
2179
2180 pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U);
2181
2182 pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU);
2183
2184 pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U);
2185
2186 pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U);
2187
2188 pCSD->PartBlockRead = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U);
2189
2190 pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U);
2191
2192 pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U);
2193
2194 pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U);
2195
2196 pCSD->Reserved2 = 0U; /*!< Reserved */
2197
2198 if(hsd->SdCard.CardType == CARD_SDSC)
2199 {
2200 pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U));
2201
2202 pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U);
2203
2204 pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U);
2205
2206 pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U);
2207
2208 pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U);
2209
2210 pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U);
2211
2212 hsd->SdCard.BlockNbr = (pCSD->DeviceSize + 1U) ;
2213 hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
2214 hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
2215
2216 hsd->SdCard.LogBlockNbr = (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U);
2217 hsd->SdCard.LogBlockSize = 512U;
2218 }
2219 else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)
2220 {
2221 /* Byte 7 */
2222 pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U));
2223
2224 hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U);
2225 hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr;
2226 hsd->SdCard.BlockSize = 512U;
2227 hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize;
2228 }
2229 else
2230 {
2231 /* Clear all the static flags */
2232 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2233 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2234 hsd->State = HAL_SD_STATE_READY;
2235 return HAL_ERROR;
2236 }
2237
2238 pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U);
2239
2240 pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U);
2241
2242 pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU);
2243
2244 pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U);
2245
2246 pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U);
2247
2248 pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U);
2249
2250 pCSD->MaxWrBlockLen= (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U);
2251
2252 pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U);
2253
2254 pCSD->Reserved3 = 0;
2255
2256 pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U);
2257
2258 pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U);
2259
2260 pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U);
2261
2262 pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U);
2263
2264 pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U);
2265
2266 pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U);
2267
2268 pCSD->ECC= (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U);
2269
2270 pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U);
2271
2272 pCSD->Reserved4 = 1;
2273
2274 return HAL_OK;
2275 }
2276
2277 /**
2278 * @brief Gets the SD status info.
2279 * @param hsd: Pointer to SD handle
2280 * @param pStatus: Pointer to the HAL_SD_CardStatusTypeDef structure that
2281 * will contain the SD card status information
2282 * @retval HAL status
2283 */
2284 HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
2285 {
2286 uint32_t sd_status[16];
2287 uint32_t errorstate;
2288 HAL_StatusTypeDef status = HAL_OK;
2289
2290 errorstate = SD_SendSDStatus(hsd, sd_status);
2291 if(errorstate != HAL_SD_ERROR_NONE)
2292 {
2293 /* Clear all the static flags */
2294 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2295 hsd->ErrorCode |= errorstate;
2296 hsd->State = HAL_SD_STATE_READY;
2297 status = HAL_ERROR;
2298 }
2299 else
2300 {
2301 pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U);
2302
2303 pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U);
2304
2305 pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U));
2306
2307 pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U) | ((sd_status[1] & 0xFF00U) << 8U) |
2308 ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U));
2309
2310 pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU);
2311
2312 pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U);
2313
2314 pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U);
2315
2316 pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU));
2317
2318 pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U);
2319
2320 pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U);
2321
2322 pStatus->UhsSpeedGrade = (uint8_t)((sd_status[3] & 0x00F0U) >> 4U);
2323 pStatus->UhsAllocationUnitSize = (uint8_t)(sd_status[3] & 0x000FU) ;
2324 pStatus->VideoSpeedClass = (uint8_t)((sd_status[4] & 0xFF000000U) >> 24U);
2325 }
2326
2327 /* Set Block Size for Card */
2328 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
2329 if(errorstate != HAL_SD_ERROR_NONE)
2330 {
2331 /* Clear all the static flags */
2332 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2333 hsd->ErrorCode = errorstate;
2334 hsd->State = HAL_SD_STATE_READY;
2335 status = HAL_ERROR;
2336 }
2337
2338 return status;
2339 }
2340
2341 /**
2342 * @brief Gets the SD card info.
2343 * @param hsd: Pointer to SD handle
2344 * @param pCardInfo: Pointer to the HAL_SD_CardInfoTypeDef structure that
2345 * will contain the SD card status information
2346 * @retval HAL status
2347 */
2348 HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
2349 {
2350 pCardInfo->CardType = (uint32_t)(hsd->SdCard.CardType);
2351 pCardInfo->CardVersion = (uint32_t)(hsd->SdCard.CardVersion);
2352 pCardInfo->Class = (uint32_t)(hsd->SdCard.Class);
2353 pCardInfo->RelCardAdd = (uint32_t)(hsd->SdCard.RelCardAdd);
2354 pCardInfo->BlockNbr = (uint32_t)(hsd->SdCard.BlockNbr);
2355 pCardInfo->BlockSize = (uint32_t)(hsd->SdCard.BlockSize);
2356 pCardInfo->LogBlockNbr = (uint32_t)(hsd->SdCard.LogBlockNbr);
2357 pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);
2358
2359 return HAL_OK;
2360 }
2361
2362 /**
2363 * @brief Enables wide bus operation for the requested card if supported by
2364 * card.
2365 * @param hsd: Pointer to SD handle
2366 * @param WideMode: Specifies the SD card wide bus mode
2367 * This parameter can be one of the following values:
2368 * @arg SDMMC_BUS_WIDE_8B: 8-bit data transfer
2369 * @arg SDMMC_BUS_WIDE_4B: 4-bit data transfer
2370 * @arg SDMMC_BUS_WIDE_1B: 1-bit data transfer
2371 * @retval HAL status
2372 */
2373 HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
2374 {
2375 SDMMC_InitTypeDef Init;
2376 uint32_t errorstate;
2377 HAL_StatusTypeDef status = HAL_OK;
2378
2379 /* Check the parameters */
2380 assert_param(IS_SDMMC_BUS_WIDE(WideMode));
2381
2382 /* Change State */
2383 hsd->State = HAL_SD_STATE_BUSY;
2384
2385 if(hsd->SdCard.CardType != CARD_SECURED)
2386 {
2387 if(WideMode == SDMMC_BUS_WIDE_8B)
2388 {
2389 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2390 }
2391 else if(WideMode == SDMMC_BUS_WIDE_4B)
2392 {
2393 errorstate = SD_WideBus_Enable(hsd);
2394
2395 hsd->ErrorCode |= errorstate;
2396 }
2397 else if(WideMode == SDMMC_BUS_WIDE_1B)
2398 {
2399 errorstate = SD_WideBus_Disable(hsd);
2400
2401 hsd->ErrorCode |= errorstate;
2402 }
2403 else
2404 {
2405 /* WideMode is not a valid argument*/
2406 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2407 }
2408 }
2409 else
2410 {
2411 /* MMC Card does not support this feature */
2412 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2413 }
2414
2415 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2416 {
2417 /* Clear all the static flags */
2418 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2419 status = HAL_ERROR;
2420 }
2421 else
2422 {
2423 /* Configure the SDMMC peripheral */
2424 Init.ClockEdge = hsd->Init.ClockEdge;
2425 Init.ClockPowerSave = hsd->Init.ClockPowerSave;
2426 Init.BusWide = WideMode;
2427 Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;
2428
2429 /* Check if user Clock div < Normal speed 25Mhz, no change in Clockdiv */
2430 if(hsd->Init.ClockDiv >= SDMMC_NSpeed_CLK_DIV)
2431 {
2432 Init.ClockDiv = hsd->Init.ClockDiv;
2433 }
2434 else if (hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED)
2435 {
2436 /* UltraHigh speed SD card,user Clock div */
2437 Init.ClockDiv = hsd->Init.ClockDiv;
2438 }
2439 else if (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED)
2440 {
2441 /* High speed SD card, Max Frequency = 50Mhz */
2442 Init.ClockDiv = SDMMC_HSpeed_CLK_DIV;
2443 }
2444 else
2445 {
2446 /* No High speed SD card, Max Frequency = 25Mhz */
2447 Init.ClockDiv = SDMMC_NSpeed_CLK_DIV;
2448 }
2449
2450 (void)SDMMC_Init(hsd->Instance, Init);
2451 }
2452
2453 /* Set Block Size for Card */
2454 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
2455 if(errorstate != HAL_SD_ERROR_NONE)
2456 {
2457 /* Clear all the static flags */
2458 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2459 hsd->ErrorCode |= errorstate;
2460 status = HAL_ERROR;
2461 }
2462
2463 /* Change State */
2464 hsd->State = HAL_SD_STATE_READY;
2465
2466 return status;
2467 }
2468
2469 /**
2470 * @brief Configure the speed bus mode
2471 * @param hsd: Pointer to the SD handle
2472 * @param SpeedMode: Specifies the SD card speed bus mode
2473 * This parameter can be one of the following values:
2474 * @arg SDMMC_SPEED_MODE_AUTO: Max speed mode supported by the card
2475 * @arg SDMMC_SPEED_MODE_DEFAULT: Default Speed/SDR12 mode
2476 * @arg SDMMC_SPEED_MODE_HIGH: High Speed/SDR25 mode
2477 * @arg SDMMC_SPEED_MODE_ULTRA: Ultra high speed mode
2478 * @retval HAL status
2479 */
2480
2481 HAL_StatusTypeDef HAL_SD_ConfigSpeedBusOperation(SD_HandleTypeDef *hsd, uint32_t SpeedMode)
2482 {
2483 uint32_t tickstart;
2484 uint32_t errorstate;
2485 HAL_StatusTypeDef status = HAL_OK;
2486
2487 /* Check the parameters */
2488 assert_param(IS_SDMMC_SPEED_MODE(SpeedMode));
2489 /* Change State */
2490 hsd->State = HAL_SD_STATE_BUSY;
2491
2492 #if (USE_SD_TRANSCEIVER != 0U)
2493 if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
2494 {
2495 switch (SpeedMode)
2496 {
2497 case SDMMC_SPEED_MODE_AUTO:
2498 {
2499 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2500 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2501 {
2502 hsd->Instance->CLKCR |= SDMMC_CLKCR_BUSSPEED;
2503 /* Enable Ultra High Speed */
2504 if (SD_UltraHighSpeed(hsd) != HAL_SD_ERROR_NONE)
2505 {
2506 if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2507 {
2508 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2509 status = HAL_ERROR;
2510 }
2511 }
2512 }
2513 else if (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED)
2514 {
2515 /* Enable High Speed */
2516 if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2517 {
2518 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2519 status = HAL_ERROR;
2520 }
2521 }
2522 else
2523 {
2524 /*Nothing to do, Use defaultSpeed */
2525 }
2526 break;
2527 }
2528 case SDMMC_SPEED_MODE_ULTRA:
2529 {
2530 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2531 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2532 {
2533 /* Enable UltraHigh Speed */
2534 if (SD_UltraHighSpeed(hsd) != HAL_SD_ERROR_NONE)
2535 {
2536 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2537 status = HAL_ERROR;
2538 }
2539 hsd->Instance->CLKCR |= SDMMC_CLKCR_BUSSPEED;
2540 }
2541 else
2542 {
2543 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2544 status = HAL_ERROR;
2545 }
2546 break;
2547 }
2548 case SDMMC_SPEED_MODE_DDR:
2549 {
2550 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2551 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2552 {
2553 /* Enable DDR Mode*/
2554 if (SD_DDR_Mode(hsd) != HAL_SD_ERROR_NONE)
2555 {
2556 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2557 status = HAL_ERROR;
2558 }
2559 hsd->Instance->CLKCR |= SDMMC_CLKCR_BUSSPEED | SDMMC_CLKCR_DDR;
2560 }
2561 else
2562 {
2563 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2564 status = HAL_ERROR;
2565 }
2566 break;
2567 }
2568 case SDMMC_SPEED_MODE_HIGH:
2569 {
2570 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2571 (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2572 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2573 {
2574 /* Enable High Speed */
2575 if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2576 {
2577 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2578 status = HAL_ERROR;
2579 }
2580 }
2581 else
2582 {
2583 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2584 status = HAL_ERROR;
2585 }
2586 break;
2587 }
2588 case SDMMC_SPEED_MODE_DEFAULT:
2589 break;
2590 default:
2591 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2592 status = HAL_ERROR;
2593 break;
2594 }
2595 }
2596 else
2597 {
2598 switch (SpeedMode)
2599 {
2600 case SDMMC_SPEED_MODE_AUTO:
2601 {
2602 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2603 (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2604 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2605 {
2606 /* Enable High Speed */
2607 if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2608 {
2609 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2610 status = HAL_ERROR;
2611 }
2612 }
2613 else
2614 {
2615 /*Nothing to do, Use defaultSpeed */
2616 }
2617 break;
2618 }
2619 case SDMMC_SPEED_MODE_HIGH:
2620 {
2621 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2622 (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2623 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2624 {
2625 /* Enable High Speed */
2626 if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2627 {
2628 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2629 status = HAL_ERROR;
2630 }
2631 }
2632 else
2633 {
2634 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2635 status = HAL_ERROR;
2636 }
2637 break;
2638 }
2639 case SDMMC_SPEED_MODE_DEFAULT:
2640 break;
2641 case SDMMC_SPEED_MODE_ULTRA: /*not valid without transceiver*/
2642 default:
2643 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2644 status = HAL_ERROR;
2645 break;
2646 }
2647 }
2648 #else
2649 switch (SpeedMode)
2650 {
2651 case SDMMC_SPEED_MODE_AUTO:
2652 {
2653 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2654 (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2655 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2656 {
2657 /* Enable High Speed */
2658 if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2659 {
2660 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2661 status = HAL_ERROR;
2662 }
2663 }
2664 else
2665 {
2666 /*Nothing to do, Use defaultSpeed */
2667 }
2668 break;
2669 }
2670 case SDMMC_SPEED_MODE_HIGH:
2671 {
2672 if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2673 (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2674 (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2675 {
2676 /* Enable High Speed */
2677 if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2678 {
2679 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2680 status = HAL_ERROR;
2681 }
2682 }
2683 else
2684 {
2685 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2686 status = HAL_ERROR;
2687 }
2688 break;
2689 }
2690 case SDMMC_SPEED_MODE_DEFAULT:
2691 break;
2692 case SDMMC_SPEED_MODE_ULTRA: /*not valid without transceiver*/
2693 default:
2694 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2695 status = HAL_ERROR;
2696 break;
2697 }
2698 #endif /* USE_SD_TRANSCEIVER */
2699
2700 /* Verify that SD card is ready to use after Speed mode switch*/
2701 tickstart = HAL_GetTick();
2702 while ((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
2703 {
2704 if ((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
2705 {
2706 hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
2707 hsd->State = HAL_SD_STATE_READY;
2708 return HAL_TIMEOUT;
2709 }
2710 }
2711
2712 /* Set Block Size for Card */
2713 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
2714 if(errorstate != HAL_SD_ERROR_NONE)
2715 {
2716 /* Clear all the static flags */
2717 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2718 hsd->ErrorCode |= errorstate;
2719 status = HAL_ERROR;
2720 }
2721
2722 /* Change State */
2723 hsd->State = HAL_SD_STATE_READY;
2724 return status;
2725 }
2726
2727 /**
2728 * @brief Gets the current sd card data state.
2729 * @param hsd: pointer to SD handle
2730 * @retval Card state
2731 */
2732 HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
2733 {
2734 uint32_t cardstate;
2735 uint32_t errorstate;
2736 uint32_t resp1 = 0;
2737
2738 errorstate = SD_SendStatus(hsd, &resp1);
2739 if(errorstate != HAL_SD_ERROR_NONE)
2740 {
2741 hsd->ErrorCode |= errorstate;
2742 }
2743
2744 cardstate = ((resp1 >> 9U) & 0x0FU);
2745
2746 return (HAL_SD_CardStateTypeDef)cardstate;
2747 }
2748
2749 /**
2750 * @brief Abort the current transfer and disable the SD.
2751 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
2752 * the configuration information for SD module.
2753 * @retval HAL status
2754 */
2755 HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
2756 {
2757 HAL_SD_CardStateTypeDef CardState;
2758
2759 /* DIsable All interrupts */
2760 __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
2761 SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);
2762
2763 /* Clear All flags */
2764 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
2765
2766 /* If IDMA Context, disable Internal DMA */
2767 hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
2768
2769 hsd->State = HAL_SD_STATE_READY;
2770
2771 /* Initialize the SD operation */
2772 hsd->Context = SD_CONTEXT_NONE;
2773
2774 CardState = HAL_SD_GetCardState(hsd);
2775 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2776 {
2777 hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2778 }
2779 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2780 {
2781 return HAL_ERROR;
2782 }
2783 return HAL_OK;
2784 }
2785
2786 /**
2787 * @brief Abort the current transfer and disable the SD (IT mode).
2788 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
2789 * the configuration information for SD module.
2790 * @retval HAL status
2791 */
2792 HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
2793 {
2794 HAL_SD_CardStateTypeDef CardState;
2795
2796 /* Disable All interrupts */
2797 __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
2798 SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);
2799
2800 /* If IDMA Context, disable Internal DMA */
2801 hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
2802
2803 /* Clear All flags */
2804 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
2805
2806 CardState = HAL_SD_GetCardState(hsd);
2807 hsd->State = HAL_SD_STATE_READY;
2808
2809 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2810 {
2811 hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2812 }
2813
2814 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2815 {
2816 return HAL_ERROR;
2817 }
2818 else
2819 {
2820 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2821 hsd->AbortCpltCallback(hsd);
2822 #else
2823 HAL_SD_AbortCallback(hsd);
2824 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2825 }
2826
2827 return HAL_OK;
2828 }
2829
2830 /**
2831 * @}
2832 */
2833
2834 /**
2835 * @}
2836 */
2837
2838 /* Private function ----------------------------------------------------------*/
2839 /** @addtogroup SD_Private_Functions
2840 * @{
2841 */
2842
2843
2844 /**
2845 * @brief Initializes the sd card.
2846 * @param hsd: Pointer to SD handle
2847 * @retval SD Card error state
2848 */
2849 static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
2850 {
2851 HAL_SD_CardCSDTypeDef CSD;
2852 uint32_t errorstate;
2853 uint16_t sd_rca = 1U;
2854
2855 /* Check the power State */
2856 if(SDMMC_GetPowerState(hsd->Instance) == 0U)
2857 {
2858 /* Power off */
2859 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
2860 }
2861
2862 if(hsd->SdCard.CardType != CARD_SECURED)
2863 {
2864 /* Send CMD2 ALL_SEND_CID */
2865 errorstate = SDMMC_CmdSendCID(hsd->Instance);
2866 if(errorstate != HAL_SD_ERROR_NONE)
2867 {
2868 return errorstate;
2869 }
2870 else
2871 {
2872 /* Get Card identification number data */
2873 hsd->CID[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
2874 hsd->CID[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
2875 hsd->CID[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
2876 hsd->CID[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
2877 }
2878 }
2879
2880 if(hsd->SdCard.CardType != CARD_SECURED)
2881 {
2882 /* Send CMD3 SET_REL_ADDR with argument 0 */
2883 /* SD Card publishes its RCA. */
2884 errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
2885 if(errorstate != HAL_SD_ERROR_NONE)
2886 {
2887 return errorstate;
2888 }
2889 }
2890 if(hsd->SdCard.CardType != CARD_SECURED)
2891 {
2892 /* Get the SD card RCA */
2893 hsd->SdCard.RelCardAdd = sd_rca;
2894
2895 /* Send CMD9 SEND_CSD with argument as card's RCA */
2896 errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2897 if(errorstate != HAL_SD_ERROR_NONE)
2898 {
2899 return errorstate;
2900 }
2901 else
2902 {
2903 /* Get Card Specific Data */
2904 hsd->CSD[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
2905 hsd->CSD[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
2906 hsd->CSD[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
2907 hsd->CSD[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
2908 }
2909 }
2910
2911 /* Get the Card Class */
2912 hsd->SdCard.Class = (SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2) >> 20U);
2913
2914 /* Get CSD parameters */
2915 if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
2916 {
2917 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2918 }
2919
2920 /* Select the Card */
2921 errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
2922 if(errorstate != HAL_SD_ERROR_NONE)
2923 {
2924 return errorstate;
2925 }
2926
2927 /* All cards are initialized */
2928 return HAL_SD_ERROR_NONE;
2929 }
2930
2931 /**
2932 * @brief Enquires cards about their operating voltage and configures clock
2933 * controls and stores SD information that will be needed in future
2934 * in the SD handle.
2935 * @param hsd: Pointer to SD handle
2936 * @retval error state
2937 */
2938 static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
2939 {
2940 __IO uint32_t count = 0U;
2941 uint32_t response = 0U, validvoltage = 0U;
2942 uint32_t errorstate;
2943 #if (USE_SD_TRANSCEIVER != 0U)
2944 uint32_t tickstart = HAL_GetTick();
2945 #endif /* USE_SD_TRANSCEIVER */
2946
2947 /* CMD0: GO_IDLE_STATE */
2948 errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2949 if(errorstate != HAL_SD_ERROR_NONE)
2950 {
2951 return errorstate;
2952 }
2953
2954 /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
2955 errorstate = SDMMC_CmdOperCond(hsd->Instance);
2956 if(errorstate != HAL_SD_ERROR_NONE)
2957 {
2958 hsd->SdCard.CardVersion = CARD_V1_X;
2959 /* CMD0: GO_IDLE_STATE */
2960 errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2961 if(errorstate != HAL_SD_ERROR_NONE)
2962 {
2963 return errorstate;
2964 }
2965
2966 }
2967 else
2968 {
2969 hsd->SdCard.CardVersion = CARD_V2_X;
2970 }
2971
2972 if( hsd->SdCard.CardVersion == CARD_V2_X)
2973 {
2974 /* SEND CMD55 APP_CMD with RCA as 0 */
2975 errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2976 if(errorstate != HAL_SD_ERROR_NONE)
2977 {
2978 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2979 }
2980 }
2981 /* SD CARD */
2982 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2983 while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
2984 {
2985 /* SEND CMD55 APP_CMD with RCA as 0 */
2986 errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2987 if(errorstate != HAL_SD_ERROR_NONE)
2988 {
2989 return errorstate;
2990 }
2991
2992 /* Send CMD41 */
2993 errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
2994 if(errorstate != HAL_SD_ERROR_NONE)
2995 {
2996 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2997 }
2998
2999 /* Get command response */
3000 response = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
3001
3002 /* Get operating voltage*/
3003 validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
3004
3005 count++;
3006 }
3007
3008 if(count >= SDMMC_MAX_VOLT_TRIAL)
3009 {
3010 return HAL_SD_ERROR_INVALID_VOLTRANGE;
3011 }
3012
3013 if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
3014 {
3015 hsd->SdCard.CardType = CARD_SDHC_SDXC;
3016 #if (USE_SD_TRANSCEIVER != 0U)
3017 if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
3018 {
3019 if((response & SD_SWITCH_1_8V_CAPACITY) == SD_SWITCH_1_8V_CAPACITY)
3020 {
3021 hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
3022
3023 /* Start switching procedue */
3024 hsd->Instance->POWER |= SDMMC_POWER_VSWITCHEN;
3025
3026 /* Send CMD11 to switch 1.8V mode */
3027 errorstate = SDMMC_CmdVoltageSwitch(hsd->Instance);
3028 if(errorstate != HAL_SD_ERROR_NONE)
3029 {
3030 return errorstate;
3031 }
3032
3033 /* Check to CKSTOP */
3034 while(( hsd->Instance->STA & SDMMC_FLAG_CKSTOP) != SDMMC_FLAG_CKSTOP)
3035 {
3036 if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3037 {
3038 return HAL_SD_ERROR_TIMEOUT;
3039 }
3040 }
3041
3042 /* Clear CKSTOP Flag */
3043 hsd->Instance->ICR = SDMMC_FLAG_CKSTOP;
3044
3045 /* Check to BusyD0 */
3046 if(( hsd->Instance->STA & SDMMC_FLAG_BUSYD0) != SDMMC_FLAG_BUSYD0)
3047 {
3048 /* Error when activate Voltage Switch in SDMMC Peripheral */
3049 return SDMMC_ERROR_UNSUPPORTED_FEATURE;
3050 }
3051 else
3052 {
3053 /* Enable Transceiver Switch PIN */
3054 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
3055 hsd->DriveTransceiver_1_8V_Callback(SET);
3056 #else
3057 HAL_SD_DriveTransceiver_1_8V_Callback(SET);
3058 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
3059
3060 /* Switch ready */
3061 hsd->Instance->POWER |= SDMMC_POWER_VSWITCH;
3062
3063 /* Check VSWEND Flag */
3064 while(( hsd->Instance->STA & SDMMC_FLAG_VSWEND) != SDMMC_FLAG_VSWEND)
3065 {
3066 if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3067 {
3068 return HAL_SD_ERROR_TIMEOUT;
3069 }
3070 }
3071
3072 /* Clear VSWEND Flag */
3073 hsd->Instance->ICR = SDMMC_FLAG_VSWEND;
3074
3075 /* Check BusyD0 status */
3076 if(( hsd->Instance->STA & SDMMC_FLAG_BUSYD0) == SDMMC_FLAG_BUSYD0)
3077 {
3078 /* Error when enabling 1.8V mode */
3079 return HAL_SD_ERROR_INVALID_VOLTRANGE;
3080 }
3081 /* Switch to 1.8V OK */
3082
3083 /* Disable VSWITCH FLAG from SDMMC Peripheral */
3084 hsd->Instance->POWER = 0x13U;
3085
3086 /* Clean Status flags */
3087 hsd->Instance->ICR = 0xFFFFFFFFU;
3088 }
3089 }
3090 }
3091 #endif /* USE_SD_TRANSCEIVER */
3092 }
3093
3094 return HAL_SD_ERROR_NONE;
3095 }
3096
3097 /**
3098 * @brief Turns the SDMMC output signals off.
3099 * @param hsd: Pointer to SD handle
3100 * @retval None
3101 */
3102 static void SD_PowerOFF(SD_HandleTypeDef *hsd)
3103 {
3104 /* Set Power State to OFF */
3105 (void)SDMMC_PowerState_OFF(hsd->Instance);
3106 }
3107
3108 /**
3109 * @brief Send Status info command.
3110 * @param hsd: pointer to SD handle
3111 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
3112 * SD Status register)
3113 * @retval error state
3114 */
3115 static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
3116 {
3117 SDMMC_DataInitTypeDef config;
3118 uint32_t errorstate;
3119 uint32_t tickstart = HAL_GetTick();
3120 uint32_t count;
3121 uint32_t *pData = pSDstatus;
3122
3123 /* Check SD response */
3124 if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3125 {
3126 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3127 }
3128
3129 /* Set block size for card if it is not equal to current block size for card */
3130 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
3131 if(errorstate != HAL_SD_ERROR_NONE)
3132 {
3133 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
3134 return errorstate;
3135 }
3136
3137 /* Send CMD55 */
3138 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3139 if(errorstate != HAL_SD_ERROR_NONE)
3140 {
3141 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
3142 return errorstate;
3143 }
3144
3145 /* Configure the SD DPSM (Data Path State Machine) */
3146 config.DataTimeOut = SDMMC_DATATIMEOUT;
3147 config.DataLength = 64U;
3148 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B;
3149 config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
3150 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3151 config.DPSM = SDMMC_DPSM_ENABLE;
3152 (void)SDMMC_ConfigData(hsd->Instance, &config);
3153
3154 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
3155 errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
3156 if(errorstate != HAL_SD_ERROR_NONE)
3157 {
3158 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
3159 return errorstate;
3160 }
3161
3162 /* Get status data */
3163 while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
3164 {
3165 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
3166 {
3167 for(count = 0U; count < 8U; count++)
3168 {
3169 *pData = SDMMC_ReadFIFO(hsd->Instance);
3170 pData++;
3171 }
3172 }
3173
3174 if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3175 {
3176 return HAL_SD_ERROR_TIMEOUT;
3177 }
3178 }
3179
3180 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
3181 {
3182 return HAL_SD_ERROR_DATA_TIMEOUT;
3183 }
3184 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
3185 {
3186 return HAL_SD_ERROR_DATA_CRC_FAIL;
3187 }
3188 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
3189 {
3190 return HAL_SD_ERROR_RX_OVERRUN;
3191 }
3192 else
3193 {
3194 /* Nothing to do */
3195 }
3196
3197 while ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DPSMACT)))
3198 {
3199 *pData = SDMMC_ReadFIFO(hsd->Instance);
3200 pData++;
3201
3202 if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3203 {
3204 return HAL_SD_ERROR_TIMEOUT;
3205 }
3206 }
3207
3208 /* Clear all the static status flags*/
3209 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3210
3211 return HAL_SD_ERROR_NONE;
3212 }
3213
3214 /**
3215 * @brief Returns the current card's status.
3216 * @param hsd: Pointer to SD handle
3217 * @param pCardStatus: pointer to the buffer that will contain the SD card
3218 * status (Card Status register)
3219 * @retval error state
3220 */
3221 static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
3222 {
3223 uint32_t errorstate;
3224
3225 if(pCardStatus == NULL)
3226 {
3227 return HAL_SD_ERROR_PARAM;
3228 }
3229
3230 /* Send Status command */
3231 errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3232 if(errorstate != HAL_SD_ERROR_NONE)
3233 {
3234 return errorstate;
3235 }
3236
3237 /* Get SD card status */
3238 *pCardStatus = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
3239
3240 return HAL_SD_ERROR_NONE;
3241 }
3242
3243 /**
3244 * @brief Enables the SDMMC wide bus mode.
3245 * @param hsd: pointer to SD handle
3246 * @retval error state
3247 */
3248 static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
3249 {
3250 uint32_t scr[2U] = {0UL, 0UL};
3251 uint32_t errorstate;
3252
3253 if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3254 {
3255 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3256 }
3257
3258 /* Get SCR Register */
3259 errorstate = SD_FindSCR(hsd, scr);
3260 if(errorstate != HAL_SD_ERROR_NONE)
3261 {
3262 return errorstate;
3263 }
3264
3265 /* If requested card supports wide bus operation */
3266 if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
3267 {
3268 /* Send CMD55 APP_CMD with argument as card's RCA.*/
3269 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3270 if(errorstate != HAL_SD_ERROR_NONE)
3271 {
3272 return errorstate;
3273 }
3274
3275 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
3276 errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
3277 if(errorstate != HAL_SD_ERROR_NONE)
3278 {
3279 return errorstate;
3280 }
3281
3282 return HAL_SD_ERROR_NONE;
3283 }
3284 else
3285 {
3286 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3287 }
3288 }
3289
3290 /**
3291 * @brief Disables the SDMMC wide bus mode.
3292 * @param hsd: Pointer to SD handle
3293 * @retval error state
3294 */
3295 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
3296 {
3297 uint32_t scr[2U] = {0UL, 0UL};
3298 uint32_t errorstate;
3299
3300 if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3301 {
3302 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3303 }
3304
3305 /* Get SCR Register */
3306 errorstate = SD_FindSCR(hsd, scr);
3307 if(errorstate != HAL_SD_ERROR_NONE)
3308 {
3309 return errorstate;
3310 }
3311
3312 /* If requested card supports 1 bit mode operation */
3313 if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)
3314 {
3315 /* Send CMD55 APP_CMD with argument as card's RCA */
3316 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3317 if(errorstate != HAL_SD_ERROR_NONE)
3318 {
3319 return errorstate;
3320 }
3321
3322 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
3323 errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);
3324 if(errorstate != HAL_SD_ERROR_NONE)
3325 {
3326 return errorstate;
3327 }
3328
3329 return HAL_SD_ERROR_NONE;
3330 }
3331 else
3332 {
3333 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3334 }
3335 }
3336
3337
3338 /**
3339 * @brief Finds the SD card SCR register value.
3340 * @param hsd: Pointer to SD handle
3341 * @param pSCR: pointer to the buffer that will contain the SCR value
3342 * @retval error state
3343 */
3344 static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
3345 {
3346 SDMMC_DataInitTypeDef config;
3347 uint32_t errorstate;
3348 uint32_t tickstart = HAL_GetTick();
3349 uint32_t index = 0U;
3350 uint32_t tempscr[2U] = {0UL, 0UL};
3351 uint32_t *scr = pSCR;
3352
3353 /* Set Block Size To 8 Bytes */
3354 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);
3355 if(errorstate != HAL_SD_ERROR_NONE)
3356 {
3357 return errorstate;
3358 }
3359
3360 /* Send CMD55 APP_CMD with argument as card's RCA */
3361 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));
3362 if(errorstate != HAL_SD_ERROR_NONE)
3363 {
3364 return errorstate;
3365 }
3366
3367 config.DataTimeOut = SDMMC_DATATIMEOUT;
3368 config.DataLength = 8U;
3369 config.DataBlockSize = SDMMC_DATABLOCK_SIZE_8B;
3370 config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
3371 config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3372 config.DPSM = SDMMC_DPSM_ENABLE;
3373 (void)SDMMC_ConfigData(hsd->Instance, &config);
3374
3375 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
3376 errorstate = SDMMC_CmdSendSCR(hsd->Instance);
3377 if(errorstate != HAL_SD_ERROR_NONE)
3378 {
3379 return errorstate;
3380 }
3381
3382 while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND | SDMMC_FLAG_DATAEND))
3383 {
3384 if((!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOE)) && (index == 0U))
3385 {
3386 tempscr[0] = SDMMC_ReadFIFO(hsd->Instance);
3387 tempscr[1] = SDMMC_ReadFIFO(hsd->Instance);
3388 index++;
3389 }
3390
3391
3392 if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3393 {
3394 return HAL_SD_ERROR_TIMEOUT;
3395 }
3396 }
3397
3398 if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
3399 {
3400 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
3401
3402 return HAL_SD_ERROR_DATA_TIMEOUT;
3403 }
3404 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
3405 {
3406 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
3407
3408 return HAL_SD_ERROR_DATA_CRC_FAIL;
3409 }
3410 else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
3411 {
3412 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
3413
3414 return HAL_SD_ERROR_RX_OVERRUN;
3415 }
3416 else
3417 {
3418 /* No error flag set */
3419 /* Clear all the static flags */
3420 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3421
3422 *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24) | ((tempscr[1] & SDMMC_8TO15BITS) << 8) |\
3423 ((tempscr[1] & SDMMC_16TO23BITS) >> 8) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24));
3424 scr++;
3425 *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24) | ((tempscr[0] & SDMMC_8TO15BITS) << 8) |\
3426 ((tempscr[0] & SDMMC_16TO23BITS) >> 8) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24));
3427
3428 }
3429
3430 return HAL_SD_ERROR_NONE;
3431 }
3432
3433 /**
3434 * @brief Wrap up reading in non-blocking mode.
3435 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
3436 * the configuration information.
3437 * @retval None
3438 */
3439 static void SD_Read_IT(SD_HandleTypeDef *hsd)
3440 {
3441 uint32_t count, data;
3442 uint8_t* tmp;
3443
3444 tmp = hsd->pRxBuffPtr;
3445
3446 if (hsd->RxXferSize >= 32U)
3447 {
3448 /* Read data from SDMMC Rx FIFO */
3449 for(count = 0U; count < 8U; count++)
3450 {
3451 data = SDMMC_ReadFIFO(hsd->Instance);
3452 *tmp = (uint8_t)(data & 0xFFU);
3453 tmp++;
3454 *tmp = (uint8_t)((data >> 8U) & 0xFFU);
3455 tmp++;
3456 *tmp = (uint8_t)((data >> 16U) & 0xFFU);
3457 tmp++;
3458 *tmp = (uint8_t)((data >> 24U) & 0xFFU);
3459 tmp++;
3460 }
3461
3462 hsd->pRxBuffPtr = tmp;
3463 hsd->RxXferSize -= 32U;
3464 }
3465 }
3466
3467 /**
3468 * @brief Wrap up writing in non-blocking mode.
3469 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
3470 * the configuration information.
3471 * @retval None
3472 */
3473 static void SD_Write_IT(SD_HandleTypeDef *hsd)
3474 {
3475 uint32_t count, data;
3476 uint8_t* tmp;
3477
3478 tmp = hsd->pTxBuffPtr;
3479
3480 if (hsd->TxXferSize >= 32U)
3481 {
3482 /* Write data to SDMMC Tx FIFO */
3483 for(count = 0U; count < 8U; count++)
3484 {
3485 data = (uint32_t)(*tmp);
3486 tmp++;
3487 data |= ((uint32_t)(*tmp) << 8U);
3488 tmp++;
3489 data |= ((uint32_t)(*tmp) << 16U);
3490 tmp++;
3491 data |= ((uint32_t)(*tmp) << 24U);
3492 tmp++;
3493 (void)SDMMC_WriteFIFO(hsd->Instance, &data);
3494 }
3495
3496 hsd->pTxBuffPtr = tmp;
3497 hsd->TxXferSize -= 32U;
3498 }
3499 }
3500
3501 /**
3502 * @brief Switches the SD card to High Speed mode.
3503 * This API must be used after "Transfer State"
3504 * @note This operation should be followed by the configuration
3505 * of PLL to have SDMMCCK clock between 50 and 120 MHz
3506 * @param hsd: SD handle
3507 * @retval SD Card error state
3508 */
3509 uint32_t SD_HighSpeed(SD_HandleTypeDef *hsd)
3510 {
3511 uint32_t errorstate = HAL_SD_ERROR_NONE;
3512 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
3513 uint32_t SD_hs[16] = {0};
3514 uint32_t count, loop = 0 ;
3515 uint32_t Timeout = HAL_GetTick();
3516
3517 if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
3518 {
3519 /* Standard Speed Card <= 12.5Mhz */
3520 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3521 }
3522
3523 if(hsd->SdCard.CardSpeed == CARD_HIGH_SPEED)
3524 {
3525 /* Initialize the Data control register */
3526 hsd->Instance->DCTRL = 0;
3527 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
3528
3529 if (errorstate != HAL_SD_ERROR_NONE)
3530 {
3531 return errorstate;
3532 }
3533
3534 /* Configure the SD DPSM (Data Path State Machine) */
3535 sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT;
3536 sdmmc_datainitstructure.DataLength = 64U;
3537 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
3538 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
3539 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3540 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
3541
3542 (void)SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure);
3543
3544
3545 errorstate = SDMMC_CmdSwitch(hsd->Instance,SDMMC_SDR25_SWITCH_PATTERN);
3546 if(errorstate != HAL_SD_ERROR_NONE)
3547 {
3548 return errorstate;
3549 }
3550
3551 while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
3552 {
3553 if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
3554 {
3555 for (count = 0U; count < 8U; count++)
3556 {
3557 SD_hs[(8U*loop)+count] = SDMMC_ReadFIFO(hsd->Instance);
3558 }
3559 loop ++;
3560 }
3561
3562 if((HAL_GetTick()-Timeout) >= SDMMC_DATATIMEOUT)
3563 {
3564 hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
3565 hsd->State= HAL_SD_STATE_READY;
3566 return HAL_SD_ERROR_TIMEOUT;
3567 }
3568 }
3569
3570 if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
3571 {
3572 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
3573
3574 return errorstate;
3575 }
3576 else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
3577 {
3578 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
3579
3580 errorstate = SDMMC_ERROR_DATA_CRC_FAIL;
3581
3582 return errorstate;
3583 }
3584 else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
3585 {
3586 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
3587
3588 errorstate = SDMMC_ERROR_RX_OVERRUN;
3589
3590 return errorstate;
3591 }
3592 else
3593 {
3594 /* No error flag set */
3595 }
3596
3597 /* Clear all the static flags */
3598 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3599
3600 /* Test if the switch mode HS is ok */
3601 if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
3602 {
3603 errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
3604 }
3605
3606 }
3607
3608 return errorstate;
3609 }
3610
3611 #if (USE_SD_TRANSCEIVER != 0U)
3612 /**
3613 * @brief Switches the SD card to Ultra High Speed mode.
3614 * This API must be used after "Transfer State"
3615 * @note This operation should be followed by the configuration
3616 * of PLL to have SDMMCCK clock between 50 and 120 MHz
3617 * @param hsd: SD handle
3618 * @retval SD Card error state
3619 */
3620 static uint32_t SD_UltraHighSpeed(SD_HandleTypeDef *hsd)
3621 {
3622 uint32_t errorstate = HAL_SD_ERROR_NONE;
3623 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
3624 uint32_t SD_hs[16] = {0};
3625 uint32_t count, loop = 0 ;
3626 uint32_t Timeout = HAL_GetTick();
3627
3628 if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
3629 {
3630 /* Standard Speed Card <= 12.5Mhz */
3631 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3632 }
3633
3634 if(hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED)
3635 {
3636 /* Initialize the Data control register */
3637 hsd->Instance->DCTRL = 0;
3638 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
3639
3640 if (errorstate != HAL_SD_ERROR_NONE)
3641 {
3642 return errorstate;
3643 }
3644
3645 /* Configure the SD DPSM (Data Path State Machine) */
3646 sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT;
3647 sdmmc_datainitstructure.DataLength = 64U;
3648 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
3649 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
3650 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3651 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
3652
3653 if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
3654 {
3655 return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
3656 }
3657
3658 errorstate = SDMMC_CmdSwitch(hsd->Instance, SDMMC_SDR104_SWITCH_PATTERN);
3659 if(errorstate != HAL_SD_ERROR_NONE)
3660 {
3661 return errorstate;
3662 }
3663
3664 while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
3665 {
3666 if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
3667 {
3668 for (count = 0U; count < 8U; count++)
3669 {
3670 SD_hs[(8U*loop)+count] = SDMMC_ReadFIFO(hsd->Instance);
3671 }
3672 loop ++;
3673 }
3674
3675 if((HAL_GetTick()-Timeout) >= SDMMC_DATATIMEOUT)
3676 {
3677 hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
3678 hsd->State= HAL_SD_STATE_READY;
3679 return HAL_SD_ERROR_TIMEOUT;
3680 }
3681 }
3682
3683 if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
3684 {
3685 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
3686
3687 return errorstate;
3688 }
3689 else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
3690 {
3691 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
3692
3693 errorstate = SDMMC_ERROR_DATA_CRC_FAIL;
3694
3695 return errorstate;
3696 }
3697 else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
3698 {
3699 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
3700
3701 errorstate = SDMMC_ERROR_RX_OVERRUN;
3702
3703 return errorstate;
3704 }
3705 else
3706 {
3707 /* No error flag set */
3708 }
3709
3710 /* Clear all the static flags */
3711 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3712
3713 /* Test if the switch mode HS is ok */
3714 if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
3715 {
3716 errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
3717 }
3718 else
3719 {
3720 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
3721 hsd->DriveTransceiver_1_8V_Callback(SET);
3722 #else
3723 HAL_SD_DriveTransceiver_1_8V_Callback(SET);
3724 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
3725 #if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2)
3726 /* Enable DelayBlock Peripheral */
3727 /* SDMMC_FB_CLK tuned feedback clock selected as receive clock, for SDR104 */
3728 MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX,SDMMC_CLKCR_SELCLKRX_1);
3729 if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK)
3730 {
3731 return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
3732 }
3733 #endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */
3734 }
3735 }
3736
3737 return errorstate;
3738 }
3739
3740 /**
3741 * @brief Switches the SD card to Double Data Rate (DDR) mode.
3742 * This API must be used after "Transfer State"
3743 * @note This operation should be followed by the configuration
3744 * of PLL to have SDMMCCK clock less than 50MHz
3745 * @param hsd: SD handle
3746 * @retval SD Card error state
3747 */
3748 static uint32_t SD_DDR_Mode(SD_HandleTypeDef *hsd)
3749 {
3750 uint32_t errorstate = HAL_SD_ERROR_NONE;
3751 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
3752 uint32_t SD_hs[16] = {0};
3753 uint32_t count, loop = 0 ;
3754 uint32_t Timeout = HAL_GetTick();
3755
3756 if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
3757 {
3758 /* Standard Speed Card <= 12.5Mhz */
3759 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3760 }
3761
3762 if(hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED)
3763 {
3764 /* Initialize the Data control register */
3765 hsd->Instance->DCTRL = 0;
3766 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
3767
3768 if (errorstate != HAL_SD_ERROR_NONE)
3769 {
3770 return errorstate;
3771 }
3772
3773 /* Configure the SD DPSM (Data Path State Machine) */
3774 sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT;
3775 sdmmc_datainitstructure.DataLength = 64U;
3776 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
3777 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
3778 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3779 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
3780
3781 if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
3782 {
3783 return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
3784 }
3785
3786 errorstate = SDMMC_CmdSwitch(hsd->Instance, SDMMC_DDR50_SWITCH_PATTERN);
3787 if(errorstate != HAL_SD_ERROR_NONE)
3788 {
3789 return errorstate;
3790 }
3791
3792 while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
3793 {
3794 if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
3795 {
3796 for (count = 0U; count < 8U; count++)
3797 {
3798 SD_hs[(8U*loop)+count] = SDMMC_ReadFIFO(hsd->Instance);
3799 }
3800 loop ++;
3801 }
3802
3803 if((HAL_GetTick()-Timeout) >= SDMMC_DATATIMEOUT)
3804 {
3805 hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
3806 hsd->State= HAL_SD_STATE_READY;
3807 return HAL_SD_ERROR_TIMEOUT;
3808 }
3809 }
3810
3811 if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
3812 {
3813 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
3814
3815 return errorstate;
3816 }
3817 else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
3818 {
3819 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
3820
3821 errorstate = SDMMC_ERROR_DATA_CRC_FAIL;
3822
3823 return errorstate;
3824 }
3825 else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
3826 {
3827 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
3828
3829 errorstate = SDMMC_ERROR_RX_OVERRUN;
3830
3831 return errorstate;
3832 }
3833 else
3834 {
3835 /* No error flag set */
3836 }
3837
3838 /* Clear all the static flags */
3839 __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3840
3841 /* Test if the switch mode is ok */
3842 if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
3843 {
3844 errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
3845 }
3846 else
3847 {
3848 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
3849 hsd->DriveTransceiver_1_8V_Callback(SET);
3850 #else
3851 HAL_SD_DriveTransceiver_1_8V_Callback(SET);
3852 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
3853 #if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2)
3854 /* Enable DelayBlock Peripheral */
3855 /* SDMMC_CKin feedback clock selected as receive clock, for DDR50 */
3856 MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX,SDMMC_CLKCR_SELCLKRX_0);
3857 if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK)
3858 {
3859 return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
3860 }
3861 #endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */
3862 }
3863 }
3864
3865 return errorstate;
3866 }
3867
3868 #endif /* USE_SD_TRANSCEIVER */
3869
3870 /**
3871 * @brief Read DMA Buffer 0 Transfer completed callbacks
3872 * @param hsd: SD handle
3873 * @retval None
3874 */
3875 __weak void HAL_SDEx_Read_DMADoubleBuf0CpltCallback(SD_HandleTypeDef *hsd)
3876 {
3877 /* Prevent unused argument(s) compilation warning */
3878 UNUSED(hsd);
3879
3880 /* NOTE : This function should not be modified, when the callback is needed,
3881 the HAL_SDEx_Read_DMADoubleBuf0CpltCallback can be implemented in the user file
3882 */
3883 }
3884
3885 /**
3886 * @brief Read DMA Buffer 1 Transfer completed callbacks
3887 * @param hsd: SD handle
3888 * @retval None
3889 */
3890 __weak void HAL_SDEx_Read_DMADoubleBuf1CpltCallback(SD_HandleTypeDef *hsd)
3891 {
3892 /* Prevent unused argument(s) compilation warning */
3893 UNUSED(hsd);
3894
3895 /* NOTE : This function should not be modified, when the callback is needed,
3896 the HAL_SDEx_Read_DMADoubleBuf1CpltCallback can be implemented in the user file
3897 */
3898 }
3899
3900 /**
3901 * @brief Write DMA Buffer 0 Transfer completed callbacks
3902 * @param hsd: SD handle
3903 * @retval None
3904 */
3905 __weak void HAL_SDEx_Write_DMADoubleBuf0CpltCallback(SD_HandleTypeDef *hsd)
3906 {
3907 /* Prevent unused argument(s) compilation warning */
3908 UNUSED(hsd);
3909
3910 /* NOTE : This function should not be modified, when the callback is needed,
3911 the HAL_SDEx_Write_DMADoubleBuf0CpltCallback can be implemented in the user file
3912 */
3913 }
3914
3915 /**
3916 * @brief Write DMA Buffer 1 Transfer completed callbacks
3917 * @param hsd: SD handle
3918 * @retval None
3919 */
3920 __weak void HAL_SDEx_Write_DMADoubleBuf1CpltCallback(SD_HandleTypeDef *hsd)
3921 {
3922 /* Prevent unused argument(s) compilation warning */
3923 UNUSED(hsd);
3924
3925 /* NOTE : This function should not be modified, when the callback is needed,
3926 the HAL_SDEx_Write_DMADoubleBuf1CpltCallback can be implemented in the user file
3927 */
3928 }
3929
3930
3931 /**
3932 * @}
3933 */
3934
3935 #endif /* HAL_SD_MODULE_ENABLED */
3936
3937 /**
3938 * @}
3939 */
3940
3941 /**
3942 * @}
3943 */
3944
3945 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/