1 /**
2 ******************************************************************************
3 * @file stm32f1xx_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 ******************************************************************************
14 * @attention
15 *
16 * Copyright (c) 2016 STMicroelectronics.
17 * All rights reserved.
18 *
19 * This software is licensed under terms that can be found in the LICENSE file
20 * in the root directory of this software component.
21 * If no LICENSE file comes with this software, it is provided AS-IS.
22 *
23 ******************************************************************************
24 @verbatim
25 ==============================================================================
26 ##### How to use this driver #####
27 ==============================================================================
28 [..]
29 This driver implements a high level communication layer for read and write from/to
30 this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by
31 the user in HAL_SD_MspInit() function (MSP layer).
32 Basically, the MSP layer configuration should be the same as we provide in the
33 examples.
34 You can easily tailor this configuration according to hardware resources.
35
36 [..]
37 This driver is a generic layered driver for SDIO memories which uses the HAL
38 SDIO driver functions to interface with SD and uSD cards devices.
39 It is used as follows:
40
41 (#)Initialize the SDIO low level resources by implementing the HAL_SD_MspInit() API:
42 (##) Enable the SDIO interface clock using __HAL_RCC_SDIO_CLK_ENABLE();
43 (##) SDIO pins configuration for SD card
44 (+++) Enable the clock for the SDIO GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
45 (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()
46 and according to your pin assignment;
47 (##) DMA configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
48 and HAL_SD_WriteBlocks_DMA() APIs).
49 (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();
50 (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.
51 (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
52 (+++) Configure the SDIO and DMA interrupt priorities using functions
53 HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority
54 (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()
55 (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT()
56 and __HAL_SD_DISABLE_IT() inside the communication process.
57 (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()
58 and __HAL_SD_CLEAR_IT()
59 (##) NVIC configuration if you need to use interrupt process (HAL_SD_ReadBlocks_IT()
60 and HAL_SD_WriteBlocks_IT() APIs).
61 (+++) Configure the SDIO interrupt priorities using function HAL_NVIC_SetPriority();
62 (+++) Enable the NVIC SDIO IRQs using function HAL_NVIC_EnableIRQ()
63 (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT()
64 and __HAL_SD_DISABLE_IT() inside the communication process.
65 (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()
66 and __HAL_SD_CLEAR_IT()
67 (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
68
69
70 *** SD Card Initialization and configuration ***
71 ================================================
72 [..]
73 To initialize the SD Card, use the HAL_SD_Init() function. It Initializes
74 SDIO Peripheral(STM32 side) and the SD Card, and put it into StandBy State (Ready for data transfer).
75 This function provide the following operations:
76
77 (#) Apply the SD Card initialization process at 400KHz and check the SD Card
78 type (Standard Capacity or High Capacity). You can change or adapt this
79 frequency by adjusting the "ClockDiv" field.
80 The SD Card frequency (SDIO_CK) is computed as follows:
81
82 SDIO_CK = SDIOCLK / (ClockDiv + 2)
83
84 In initialization mode and according to the SD Card standard,
85 make sure that the SDIO_CK frequency doesn't exceed 400KHz.
86
87 This phase of initialization is done through SDIO_Init() and
88 SDIO_PowerState_ON() SDIO low level APIs.
89
90 (#) Initialize the SD card. The API used is HAL_SD_InitCard().
91 This phase allows the card initialization and identification
92 and check the SD Card type (Standard Capacity or High Capacity)
93 The initialization flow is compatible with SD standard.
94
95 This API (HAL_SD_InitCard()) could be used also to reinitialize the card in case
96 of plug-off plug-in.
97
98 (#) Configure the SD Card Data transfer frequency. You can change or adapt this
99 frequency by adjusting the "ClockDiv" field.
100 In transfer mode and according to the SD Card standard, make sure that the
101 SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
102 To be able to use a frequency higher than 24MHz, you should use the SDIO
103 peripheral in bypass mode. Refer to the corresponding reference manual
104 for more details.
105
106 (#) Select the corresponding SD Card according to the address read with the step 2.
107
108 (#) Configure the SD Card in wide bus mode: 4-bits data.
109
110 *** SD Card Read operation ***
111 ==============================
112 [..]
113 (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
114 This function support only 512-bytes block length (the block size should be
115 chosen as 512 bytes).
116 You can choose either one block read operation or multiple block read operation
117 by adjusting the "NumberOfBlocks" parameter.
118 After this, you have to ensure that the transfer is done correctly. The check is done
119 through HAL_SD_GetCardState() function for SD card state.
120
121 (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
122 This function support only 512-bytes block length (the block size should be
123 chosen as 512 bytes).
124 You can choose either one block read operation or multiple block read operation
125 by adjusting the "NumberOfBlocks" parameter.
126 After this, you have to ensure that the transfer is done correctly. The check is done
127 through HAL_SD_GetCardState() function for SD card state.
128 You could also check the DMA transfer process through the SD Rx interrupt event.
129
130 (+) You can read from SD card in Interrupt mode by using function HAL_SD_ReadBlocks_IT().
131 This function support only 512-bytes block length (the block size should be
132 chosen as 512 bytes).
133 You can choose either one block read operation or multiple block read operation
134 by adjusting the "NumberOfBlocks" parameter.
135 After this, you have to ensure that the transfer is done correctly. The check is done
136 through HAL_SD_GetCardState() function for SD card state.
137 You could also check the IT transfer process through the SD Rx interrupt event.
138
139 *** SD Card Write operation ***
140 ===============================
141 [..]
142 (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
143 This function support only 512-bytes block length (the block size should be
144 chosen as 512 bytes).
145 You can choose either one block read operation or multiple block read operation
146 by adjusting the "NumberOfBlocks" parameter.
147 After this, you have to ensure that the transfer is done correctly. The check is done
148 through HAL_SD_GetCardState() function for SD card state.
149
150 (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
151 This function support only 512-bytes block length (the block size should be
152 chosen as 512 bytes).
153 You can choose either one block read operation or multiple block read operation
154 by adjusting the "NumberOfBlocks" parameter.
155 After this, you have to ensure that the transfer is done correctly. The check is done
156 through HAL_SD_GetCardState() function for SD card state.
157 You could also check the DMA transfer process through the SD Tx interrupt event.
158
159 (+) You can write to SD card in Interrupt mode by using function HAL_SD_WriteBlocks_IT().
160 This function support only 512-bytes block length (the block size should be
161 chosen as 512 bytes).
162 You can choose either one block read operation or multiple block read operation
163 by adjusting the "NumberOfBlocks" parameter.
164 After this, you have to ensure that the transfer is done correctly. The check is done
165 through HAL_SD_GetCardState() function for SD card state.
166 You could also check the IT transfer process through the SD Tx interrupt event.
167
168 *** SD card status ***
169 ======================
170 [..]
171 (+) The SD Status contains status bits that are related to the SD Memory
172 Card proprietary features. To get SD card status use the HAL_SD_GetCardStatus().
173
174 *** SD card information ***
175 ===========================
176 [..]
177 (+) To get SD card information, you can use the function HAL_SD_GetCardInfo().
178 It returns useful information about the SD card such as block size, card type,
179 block number ...
180
181 *** SD card CSD register ***
182 ============================
183 (+) The HAL_SD_GetCardCSD() API allows to get the parameters of the CSD register.
184 Some of the CSD parameters are useful for card initialization and identification.
185
186 *** SD card CID register ***
187 ============================
188 (+) The HAL_SD_GetCardCID() API allows to get the parameters of the CID register.
189 Some of the CSD parameters are useful for card initialization and identification.
190
191 *** SD HAL driver macros list ***
192 ==================================
193 [..]
194 Below the list of most used macros in SD HAL driver.
195
196 (+) __HAL_SD_ENABLE : Enable the SD device
197 (+) __HAL_SD_DISABLE : Disable the SD device
198 (+) __HAL_SD_DMA_ENABLE: Enable the SDIO DMA transfer
199 (+) __HAL_SD_DMA_DISABLE: Disable the SDIO DMA transfer
200 (+) __HAL_SD_ENABLE_IT: Enable the SD device interrupt
201 (+) __HAL_SD_DISABLE_IT: Disable the SD device interrupt
202 (+) __HAL_SD_GET_FLAG:Check whether the specified SD flag is set or not
203 (+) __HAL_SD_CLEAR_FLAG: Clear the SD's pending flags
204
205 (@) You can refer to the SD HAL driver header file for more useful macros
206
207 *** Callback registration ***
208 =============================================
209 [..]
210 The compilation define USE_HAL_SD_REGISTER_CALLBACKS when set to 1
211 allows the user to configure dynamically the driver callbacks.
212
213 Use Functions HAL_SD_RegisterCallback() to register a user callback,
214 it allows to register following callbacks:
215 (+) TxCpltCallback : callback when a transmission transfer is completed.
216 (+) RxCpltCallback : callback when a reception transfer is completed.
217 (+) ErrorCallback : callback when error occurs.
218 (+) AbortCpltCallback : callback when abort is completed.
219 (+) MspInitCallback : SD MspInit.
220 (+) MspDeInitCallback : SD MspDeInit.
221 This function takes as parameters the HAL peripheral handle, the Callback ID
222 and a pointer to the user callback function.
223
224 Use function HAL_SD_UnRegisterCallback() to reset a callback to the default
225 weak (surcharged) function. It allows to reset following callbacks:
226 (+) TxCpltCallback : callback when a transmission transfer is completed.
227 (+) RxCpltCallback : callback when a reception transfer is completed.
228 (+) ErrorCallback : callback when error occurs.
229 (+) AbortCpltCallback : callback when abort is completed.
230 (+) MspInitCallback : SD MspInit.
231 (+) MspDeInitCallback : SD MspDeInit.
232 This function) takes as parameters the HAL peripheral handle and the Callback ID.
233
234 By default, after the HAL_SD_Init and if the state is HAL_SD_STATE_RESET
235 all callbacks are reset to the corresponding legacy weak (surcharged) functions.
236 Exception done for MspInit and MspDeInit callbacks that are respectively
237 reset to the legacy weak (surcharged) functions in the HAL_SD_Init
238 and HAL_SD_DeInit only when these callbacks are null (not registered beforehand).
239 If not, MspInit or MspDeInit are not null, the HAL_SD_Init and HAL_SD_DeInit
240 keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
241
242 Callbacks can be registered/unregistered in READY state only.
243 Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
244 in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
245 during the Init/DeInit.
246 In that case first register the MspInit/MspDeInit user callbacks
247 using HAL_SD_RegisterCallback before calling HAL_SD_DeInit
248 or HAL_SD_Init function.
249
250 When The compilation define USE_HAL_SD_REGISTER_CALLBACKS is set to 0 or
251 not defined, the callback registering feature is not available
252 and weak (surcharged) callbacks are used.
253
254 @endverbatim
255 ******************************************************************************
256 */
257
258 /* Includes ------------------------------------------------------------------*/
259 #include "stm32f1xx_hal.h"
260
261 #if defined(SDIO)
262
263 /** @addtogroup STM32F1xx_HAL_Driver
264 * @{
265 */
266
267 /** @addtogroup SD
268 * @{
269 */
270
271 #ifdef HAL_SD_MODULE_ENABLED
272
273 /* Private typedef -----------------------------------------------------------*/
274 /* Private define ------------------------------------------------------------*/
275 /** @addtogroup SD_Private_Defines
276 * @{
277 */
278
279 /**
280 * @}
281 */
282
283 /* Private macro -------------------------------------------------------------*/
284 /* Private variables ---------------------------------------------------------*/
285 /* Private function prototypes -----------------------------------------------*/
286 /* Private functions ---------------------------------------------------------*/
287 /** @defgroup SD_Private_Functions SD Private Functions
288 * @{
289 */
290 static uint32_t SD_InitCard(SD_HandleTypeDef *hsd);
291 static uint32_t SD_PowerON(SD_HandleTypeDef *hsd);
292 static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus);
293 static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
294 static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd);
295 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd);
296 static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
297 static void SD_PowerOFF(SD_HandleTypeDef *hsd);
298 static void SD_Write_IT(SD_HandleTypeDef *hsd);
299 static void SD_Read_IT(SD_HandleTypeDef *hsd);
300 static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
301 static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
302 static void SD_DMAError(DMA_HandleTypeDef *hdma);
303 static void SD_DMATxAbort(DMA_HandleTypeDef *hdma);
304 static void SD_DMARxAbort(DMA_HandleTypeDef *hdma);
305 /**
306 * @}
307 */
308
309 /* Exported functions --------------------------------------------------------*/
310 /** @addtogroup SD_Exported_Functions
311 * @{
312 */
313
314 /** @addtogroup SD_Exported_Functions_Group1
315 * @brief Initialization and de-initialization functions
316 *
317 @verbatim
318 ==============================================================================
319 ##### Initialization and de-initialization functions #####
320 ==============================================================================
321 [..]
322 This section provides functions allowing to initialize/de-initialize the SD
323 card device to be ready for use.
324
325 @endverbatim
326 * @{
327 */
328
329 /**
330 * @brief Initializes the SD according to the specified parameters in the
331 SD_HandleTypeDef and create the associated handle.
332 * @param hsd: Pointer to the SD handle
333 * @retval HAL status
334 */
HAL_SD_Init(SD_HandleTypeDef * hsd)335 HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
336 {
337 /* Check the SD handle allocation */
338 if(hsd == NULL)
339 {
340 return HAL_ERROR;
341 }
342
343 /* Check the parameters */
344 assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));
345 assert_param(IS_SDIO_CLOCK_EDGE(hsd->Init.ClockEdge));
346 assert_param(IS_SDIO_CLOCK_BYPASS(hsd->Init.ClockBypass));
347 assert_param(IS_SDIO_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
348 assert_param(IS_SDIO_BUS_WIDE(hsd->Init.BusWide));
349 assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
350 assert_param(IS_SDIO_CLKDIV(hsd->Init.ClockDiv));
351
352 if(hsd->State == HAL_SD_STATE_RESET)
353 {
354 /* Allocate lock resource and initialize it */
355 hsd->Lock = HAL_UNLOCKED;
356 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
357 /* Reset Callback pointers in HAL_SD_STATE_RESET only */
358 hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
359 hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
360 hsd->ErrorCallback = HAL_SD_ErrorCallback;
361 hsd->AbortCpltCallback = HAL_SD_AbortCallback;
362
363 if(hsd->MspInitCallback == NULL)
364 {
365 hsd->MspInitCallback = HAL_SD_MspInit;
366 }
367
368 /* Init the low level hardware */
369 hsd->MspInitCallback(hsd);
370 #else
371 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
372 HAL_SD_MspInit(hsd);
373 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
374 }
375
376 hsd->State = HAL_SD_STATE_BUSY;
377
378 /* Initialize the Card parameters */
379 if (HAL_SD_InitCard(hsd) != HAL_OK)
380 {
381 return HAL_ERROR;
382 }
383
384 /* Initialize the error code */
385 hsd->ErrorCode = HAL_SD_ERROR_NONE;
386
387 /* Initialize the SD operation */
388 hsd->Context = SD_CONTEXT_NONE;
389
390 /* Initialize the SD state */
391 hsd->State = HAL_SD_STATE_READY;
392
393 return HAL_OK;
394 }
395
396 /**
397 * @brief Initializes the SD Card.
398 * @param hsd: Pointer to SD handle
399 * @note This function initializes the SD card. It could be used when a card
400 re-initialization is needed.
401 * @retval HAL status
402 */
HAL_SD_InitCard(SD_HandleTypeDef * hsd)403 HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
404 {
405 uint32_t errorstate;
406 SD_InitTypeDef Init;
407
408 /* Default SDIO peripheral configuration for SD card initialization */
409 Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
410 Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
411 Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
412 Init.BusWide = SDIO_BUS_WIDE_1B;
413 Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
414 Init.ClockDiv = SDIO_INIT_CLK_DIV;
415
416 /* Initialize SDIO peripheral interface with default configuration */
417 SDIO_Init(hsd->Instance, Init);
418
419 /* Disable SDIO Clock */
420 __HAL_SD_DISABLE(hsd);
421
422 /* Set Power State to ON */
423 (void)SDIO_PowerState_ON(hsd->Instance);
424
425 /* Enable SDIO Clock */
426 __HAL_SD_ENABLE(hsd);
427
428 /* Required power up waiting time before starting the SD initialization sequence */
429 HAL_Delay(2);
430
431 /* Identify card operating voltage */
432 errorstate = SD_PowerON(hsd);
433 if(errorstate != HAL_SD_ERROR_NONE)
434 {
435 hsd->State = HAL_SD_STATE_READY;
436 hsd->ErrorCode |= errorstate;
437 return HAL_ERROR;
438 }
439
440 /* Card initialization */
441 errorstate = SD_InitCard(hsd);
442 if(errorstate != HAL_SD_ERROR_NONE)
443 {
444 hsd->State = HAL_SD_STATE_READY;
445 hsd->ErrorCode |= errorstate;
446 return HAL_ERROR;
447 }
448
449 /* Set Block Size for Card */
450 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
451 if(errorstate != HAL_SD_ERROR_NONE)
452 {
453 /* Clear all the static flags */
454 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
455 hsd->ErrorCode |= errorstate;
456 hsd->State = HAL_SD_STATE_READY;
457 return HAL_ERROR;
458 }
459
460 return HAL_OK;
461 }
462
463 /**
464 * @brief De-Initializes the SD card.
465 * @param hsd: Pointer to SD handle
466 * @retval HAL status
467 */
HAL_SD_DeInit(SD_HandleTypeDef * hsd)468 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
469 {
470 /* Check the SD handle allocation */
471 if(hsd == NULL)
472 {
473 return HAL_ERROR;
474 }
475
476 /* Check the parameters */
477 assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));
478
479 hsd->State = HAL_SD_STATE_BUSY;
480
481 /* Set SD power state to off */
482 SD_PowerOFF(hsd);
483
484 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
485 if(hsd->MspDeInitCallback == NULL)
486 {
487 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
488 }
489
490 /* DeInit the low level hardware */
491 hsd->MspDeInitCallback(hsd);
492 #else
493 /* De-Initialize the MSP layer */
494 HAL_SD_MspDeInit(hsd);
495 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
496
497 hsd->ErrorCode = HAL_SD_ERROR_NONE;
498 hsd->State = HAL_SD_STATE_RESET;
499
500 return HAL_OK;
501 }
502
503
504 /**
505 * @brief Initializes the SD MSP.
506 * @param hsd: Pointer to SD handle
507 * @retval None
508 */
HAL_SD_MspInit(SD_HandleTypeDef * hsd)509 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
510 {
511 /* Prevent unused argument(s) compilation warning */
512 UNUSED(hsd);
513
514 /* NOTE : This function should not be modified, when the callback is needed,
515 the HAL_SD_MspInit could be implemented in the user file
516 */
517 }
518
519 /**
520 * @brief De-Initialize SD MSP.
521 * @param hsd: Pointer to SD handle
522 * @retval None
523 */
HAL_SD_MspDeInit(SD_HandleTypeDef * hsd)524 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
525 {
526 /* Prevent unused argument(s) compilation warning */
527 UNUSED(hsd);
528
529 /* NOTE : This function should not be modified, when the callback is needed,
530 the HAL_SD_MspDeInit could be implemented in the user file
531 */
532 }
533
534 /**
535 * @}
536 */
537
538 /** @addtogroup SD_Exported_Functions_Group2
539 * @brief Data transfer functions
540 *
541 @verbatim
542 ==============================================================================
543 ##### IO operation functions #####
544 ==============================================================================
545 [..]
546 This subsection provides a set of functions allowing to manage the data
547 transfer from/to SD card.
548
549 @endverbatim
550 * @{
551 */
552
553 /**
554 * @brief Reads block(s) from a specified address in a card. The Data transfer
555 * is managed by polling mode.
556 * @note This API should be followed by a check on the card state through
557 * HAL_SD_GetCardState().
558 * @param hsd: Pointer to SD handle
559 * @param pData: pointer to the buffer that will contain the received data
560 * @param BlockAdd: Block Address from where data is to be read
561 * @param NumberOfBlocks: Number of SD blocks to read
562 * @param Timeout: Specify timeout value
563 * @retval HAL status
564 */
HAL_SD_ReadBlocks(SD_HandleTypeDef * hsd,uint8_t * pData,uint32_t BlockAdd,uint32_t NumberOfBlocks,uint32_t Timeout)565 HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
566 {
567 SDIO_DataInitTypeDef config;
568 uint32_t errorstate;
569 uint32_t tickstart = HAL_GetTick();
570 uint32_t count, data, dataremaining;
571 uint32_t add = BlockAdd;
572 uint8_t *tempbuff = pData;
573
574 if(NULL == pData)
575 {
576 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
577 return HAL_ERROR;
578 }
579
580 if(hsd->State == HAL_SD_STATE_READY)
581 {
582 hsd->ErrorCode = HAL_SD_ERROR_NONE;
583
584 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
585 {
586 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
587 return HAL_ERROR;
588 }
589
590 hsd->State = HAL_SD_STATE_BUSY;
591
592 /* Initialize data control register */
593 hsd->Instance->DCTRL = 0U;
594
595 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
596 {
597 add *= 512U;
598 }
599
600 /* Configure the SD DPSM (Data Path State Machine) */
601 config.DataTimeOut = SDMMC_DATATIMEOUT;
602 config.DataLength = NumberOfBlocks * BLOCKSIZE;
603 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
604 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
605 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
606 config.DPSM = SDIO_DPSM_ENABLE;
607 (void)SDIO_ConfigData(hsd->Instance, &config);
608
609 /* Read block(s) in polling mode */
610 if(NumberOfBlocks > 1U)
611 {
612 hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
613
614 /* Read Multi Block command */
615 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
616 }
617 else
618 {
619 hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
620
621 /* Read Single Block command */
622 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
623 }
624 if(errorstate != HAL_SD_ERROR_NONE)
625 {
626 /* Clear all the static flags */
627 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
628 hsd->ErrorCode |= errorstate;
629 hsd->State = HAL_SD_STATE_READY;
630 hsd->Context = SD_CONTEXT_NONE;
631 return HAL_ERROR;
632 }
633
634 /* Poll on SDIO flags */
635 dataremaining = config.DataLength;
636 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
637 {
638 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))
639 {
640 /* Read data from SDIO Rx FIFO */
641 for(count = 0U; count < 8U; count++)
642 {
643 data = SDIO_ReadFIFO(hsd->Instance);
644 *tempbuff = (uint8_t)(data & 0xFFU);
645 tempbuff++;
646 dataremaining--;
647 *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
648 tempbuff++;
649 dataremaining--;
650 *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
651 tempbuff++;
652 dataremaining--;
653 *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
654 tempbuff++;
655 dataremaining--;
656 }
657 }
658
659 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
660 {
661 /* Clear all the static flags */
662 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
663 hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
664 hsd->State= HAL_SD_STATE_READY;
665 hsd->Context = SD_CONTEXT_NONE;
666 return HAL_TIMEOUT;
667 }
668 }
669
670 /* Send stop transmission command in case of multiblock read */
671 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
672 {
673 if(hsd->SdCard.CardType != CARD_SECURED)
674 {
675 /* Send stop transmission command */
676 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
677 if(errorstate != HAL_SD_ERROR_NONE)
678 {
679 /* Clear all the static flags */
680 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
681 hsd->ErrorCode |= errorstate;
682 hsd->State = HAL_SD_STATE_READY;
683 hsd->Context = SD_CONTEXT_NONE;
684 return HAL_ERROR;
685 }
686 }
687 }
688
689 /* Get error state */
690 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
691 {
692 /* Clear all the static flags */
693 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
694 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
695 hsd->State = HAL_SD_STATE_READY;
696 hsd->Context = SD_CONTEXT_NONE;
697 return HAL_ERROR;
698 }
699 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
700 {
701 /* Clear all the static flags */
702 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
703 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
704 hsd->State = HAL_SD_STATE_READY;
705 hsd->Context = SD_CONTEXT_NONE;
706 return HAL_ERROR;
707 }
708 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
709 {
710 /* Clear all the static flags */
711 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
712 hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
713 hsd->State = HAL_SD_STATE_READY;
714 hsd->Context = SD_CONTEXT_NONE;
715 return HAL_ERROR;
716 }
717 else
718 {
719 /* Nothing to do */
720 }
721
722 /* Empty FIFO if there is still any data */
723 while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))
724 {
725 data = SDIO_ReadFIFO(hsd->Instance);
726 *tempbuff = (uint8_t)(data & 0xFFU);
727 tempbuff++;
728 dataremaining--;
729 *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
730 tempbuff++;
731 dataremaining--;
732 *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
733 tempbuff++;
734 dataremaining--;
735 *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
736 tempbuff++;
737 dataremaining--;
738
739 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
740 {
741 /* Clear all the static flags */
742 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
743 hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
744 hsd->State= HAL_SD_STATE_READY;
745 hsd->Context = SD_CONTEXT_NONE;
746 return HAL_ERROR;
747 }
748 }
749
750 /* Clear all the static flags */
751 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
752
753 hsd->State = HAL_SD_STATE_READY;
754
755 return HAL_OK;
756 }
757 else
758 {
759 hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
760 return HAL_ERROR;
761 }
762 }
763
764 /**
765 * @brief Allows to write block(s) to a specified address in a card. The Data
766 * transfer is managed by polling mode.
767 * @note This API should be followed by a check on the card state through
768 * HAL_SD_GetCardState().
769 * @param hsd: Pointer to SD handle
770 * @param pData: pointer to the buffer that will contain the data to transmit
771 * @param BlockAdd: Block Address where data will be written
772 * @param NumberOfBlocks: Number of SD blocks to write
773 * @param Timeout: Specify timeout value
774 * @retval HAL status
775 */
HAL_SD_WriteBlocks(SD_HandleTypeDef * hsd,uint8_t * pData,uint32_t BlockAdd,uint32_t NumberOfBlocks,uint32_t Timeout)776 HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
777 {
778 SDIO_DataInitTypeDef config;
779 uint32_t errorstate;
780 uint32_t tickstart = HAL_GetTick();
781 uint32_t count, data, dataremaining;
782 uint32_t add = BlockAdd;
783 uint8_t *tempbuff = pData;
784
785 if(NULL == pData)
786 {
787 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
788 return HAL_ERROR;
789 }
790
791 if(hsd->State == HAL_SD_STATE_READY)
792 {
793 hsd->ErrorCode = HAL_SD_ERROR_NONE;
794
795 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
796 {
797 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
798 return HAL_ERROR;
799 }
800
801 hsd->State = HAL_SD_STATE_BUSY;
802
803 /* Initialize data control register */
804 hsd->Instance->DCTRL = 0U;
805
806 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
807 {
808 add *= 512U;
809 }
810
811 /* Configure the SD DPSM (Data Path State Machine) */
812 config.DataTimeOut = SDMMC_DATATIMEOUT;
813 config.DataLength = NumberOfBlocks * BLOCKSIZE;
814 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
815 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
816 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
817 config.DPSM = SDIO_DPSM_ENABLE;
818 (void)SDIO_ConfigData(hsd->Instance, &config);
819
820 /* Write Blocks in Polling mode */
821 if(NumberOfBlocks > 1U)
822 {
823 hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
824
825 /* Write Multi Block command */
826 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
827 }
828 else
829 {
830 hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
831
832 /* Write Single Block command */
833 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
834 }
835 if(errorstate != HAL_SD_ERROR_NONE)
836 {
837 /* Clear all the static flags */
838 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
839 hsd->ErrorCode |= errorstate;
840 hsd->State = HAL_SD_STATE_READY;
841 hsd->Context = SD_CONTEXT_NONE;
842 return HAL_ERROR;
843 }
844
845 /* Write block(s) in polling mode */
846 dataremaining = config.DataLength;
847 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
848 {
849 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) && (dataremaining > 0U))
850 {
851 /* Write data to SDIO Tx FIFO */
852 for(count = 0U; count < 8U; count++)
853 {
854 data = (uint32_t)(*tempbuff);
855 tempbuff++;
856 dataremaining--;
857 data |= ((uint32_t)(*tempbuff) << 8U);
858 tempbuff++;
859 dataremaining--;
860 data |= ((uint32_t)(*tempbuff) << 16U);
861 tempbuff++;
862 dataremaining--;
863 data |= ((uint32_t)(*tempbuff) << 24U);
864 tempbuff++;
865 dataremaining--;
866 (void)SDIO_WriteFIFO(hsd->Instance, &data);
867 }
868 }
869
870 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
871 {
872 /* Clear all the static flags */
873 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
874 hsd->ErrorCode |= errorstate;
875 hsd->State = HAL_SD_STATE_READY;
876 hsd->Context = SD_CONTEXT_NONE;
877 return HAL_TIMEOUT;
878 }
879 }
880
881 /* Send stop transmission command in case of multiblock write */
882 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
883 {
884 if(hsd->SdCard.CardType != CARD_SECURED)
885 {
886 /* Send stop transmission command */
887 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
888 if(errorstate != HAL_SD_ERROR_NONE)
889 {
890 /* Clear all the static flags */
891 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
892 hsd->ErrorCode |= errorstate;
893 hsd->State = HAL_SD_STATE_READY;
894 hsd->Context = SD_CONTEXT_NONE;
895 return HAL_ERROR;
896 }
897 }
898 }
899
900 /* Get error state */
901 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
902 {
903 /* Clear all the static flags */
904 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
905 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
906 hsd->State = HAL_SD_STATE_READY;
907 hsd->Context = SD_CONTEXT_NONE;
908 return HAL_ERROR;
909 }
910 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
911 {
912 /* Clear all the static flags */
913 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
914 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
915 hsd->State = HAL_SD_STATE_READY;
916 hsd->Context = SD_CONTEXT_NONE;
917 return HAL_ERROR;
918 }
919 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
920 {
921 /* Clear all the static flags */
922 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
923 hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
924 hsd->State = HAL_SD_STATE_READY;
925 hsd->Context = SD_CONTEXT_NONE;
926 return HAL_ERROR;
927 }
928 else
929 {
930 /* Nothing to do */
931 }
932
933 /* Clear all the static flags */
934 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
935
936 hsd->State = HAL_SD_STATE_READY;
937
938 return HAL_OK;
939 }
940 else
941 {
942 hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
943 return HAL_ERROR;
944 }
945 }
946
947 /**
948 * @brief Reads block(s) from a specified address in a card. The Data transfer
949 * is managed in interrupt mode.
950 * @note This API should be followed by a check on the card state through
951 * HAL_SD_GetCardState().
952 * @note You could also check the IT transfer process through the SD Rx
953 * interrupt event.
954 * @param hsd: Pointer to SD handle
955 * @param pData: Pointer to the buffer that will contain the received data
956 * @param BlockAdd: Block Address from where data is to be read
957 * @param NumberOfBlocks: Number of blocks to read.
958 * @retval HAL status
959 */
HAL_SD_ReadBlocks_IT(SD_HandleTypeDef * hsd,uint8_t * pData,uint32_t BlockAdd,uint32_t NumberOfBlocks)960 HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
961 {
962 SDIO_DataInitTypeDef config;
963 uint32_t errorstate;
964 uint32_t add = BlockAdd;
965
966 if(NULL == pData)
967 {
968 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
969 return HAL_ERROR;
970 }
971
972 if(hsd->State == HAL_SD_STATE_READY)
973 {
974 hsd->ErrorCode = HAL_SD_ERROR_NONE;
975
976 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
977 {
978 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
979 return HAL_ERROR;
980 }
981
982 hsd->State = HAL_SD_STATE_BUSY;
983
984 /* Initialize data control register */
985 hsd->Instance->DCTRL = 0U;
986
987 hsd->pRxBuffPtr = pData;
988 hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
989
990 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF));
991
992 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
993 {
994 add *= 512U;
995 }
996
997 /* Configure the SD DPSM (Data Path State Machine) */
998 config.DataTimeOut = SDMMC_DATATIMEOUT;
999 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1000 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1001 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1002 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1003 config.DPSM = SDIO_DPSM_ENABLE;
1004 (void)SDIO_ConfigData(hsd->Instance, &config);
1005
1006 /* Read Blocks in IT mode */
1007 if(NumberOfBlocks > 1U)
1008 {
1009 hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);
1010
1011 /* Read Multi Block command */
1012 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1013 }
1014 else
1015 {
1016 hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);
1017
1018 /* Read Single Block command */
1019 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1020 }
1021 if(errorstate != HAL_SD_ERROR_NONE)
1022 {
1023 /* Clear all the static flags */
1024 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1025 hsd->ErrorCode |= errorstate;
1026 hsd->State = HAL_SD_STATE_READY;
1027 hsd->Context = SD_CONTEXT_NONE;
1028 return HAL_ERROR;
1029 }
1030
1031 return HAL_OK;
1032 }
1033 else
1034 {
1035 return HAL_BUSY;
1036 }
1037 }
1038
1039 /**
1040 * @brief Writes block(s) to a specified address in a card. The Data transfer
1041 * is managed in interrupt mode.
1042 * @note This API should be followed by a check on the card state through
1043 * HAL_SD_GetCardState().
1044 * @note You could also check the IT transfer process through the SD Tx
1045 * interrupt event.
1046 * @param hsd: Pointer to SD handle
1047 * @param pData: Pointer to the buffer that will contain the data to transmit
1048 * @param BlockAdd: Block Address where data will be written
1049 * @param NumberOfBlocks: Number of blocks to write
1050 * @retval HAL status
1051 */
HAL_SD_WriteBlocks_IT(SD_HandleTypeDef * hsd,uint8_t * pData,uint32_t BlockAdd,uint32_t NumberOfBlocks)1052 HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1053 {
1054 SDIO_DataInitTypeDef config;
1055 uint32_t errorstate;
1056 uint32_t add = BlockAdd;
1057
1058 if(NULL == pData)
1059 {
1060 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1061 return HAL_ERROR;
1062 }
1063
1064 if(hsd->State == HAL_SD_STATE_READY)
1065 {
1066 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1067
1068 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1069 {
1070 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1071 return HAL_ERROR;
1072 }
1073
1074 hsd->State = HAL_SD_STATE_BUSY;
1075
1076 /* Initialize data control register */
1077 hsd->Instance->DCTRL = 0U;
1078
1079 hsd->pTxBuffPtr = pData;
1080 hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
1081
1082 /* Enable transfer interrupts */
1083 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE));
1084
1085 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1086 {
1087 add *= 512U;
1088 }
1089
1090 /* Write Blocks in Polling mode */
1091 if(NumberOfBlocks > 1U)
1092 {
1093 hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);
1094
1095 /* Write Multi Block command */
1096 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1097 }
1098 else
1099 {
1100 hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);
1101
1102 /* Write Single Block command */
1103 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1104 }
1105 if(errorstate != HAL_SD_ERROR_NONE)
1106 {
1107 /* Clear all the static flags */
1108 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1109 hsd->ErrorCode |= errorstate;
1110 hsd->State = HAL_SD_STATE_READY;
1111 hsd->Context = SD_CONTEXT_NONE;
1112 return HAL_ERROR;
1113 }
1114
1115 /* Configure the SD DPSM (Data Path State Machine) */
1116 config.DataTimeOut = SDMMC_DATATIMEOUT;
1117 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1118 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1119 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1120 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1121 config.DPSM = SDIO_DPSM_ENABLE;
1122 (void)SDIO_ConfigData(hsd->Instance, &config);
1123
1124 return HAL_OK;
1125 }
1126 else
1127 {
1128 return HAL_BUSY;
1129 }
1130 }
1131
1132 /**
1133 * @brief Reads block(s) from a specified address in a card. The Data transfer
1134 * is managed by DMA mode.
1135 * @note This API should be followed by a check on the card state through
1136 * HAL_SD_GetCardState().
1137 * @note You could also check the DMA transfer process through the SD Rx
1138 * interrupt event.
1139 * @param hsd: Pointer SD handle
1140 * @param pData: Pointer to the buffer that will contain the received data
1141 * @param BlockAdd: Block Address from where data is to be read
1142 * @param NumberOfBlocks: Number of blocks to read.
1143 * @retval HAL status
1144 */
HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef * hsd,uint8_t * pData,uint32_t BlockAdd,uint32_t NumberOfBlocks)1145 HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1146 {
1147 SDIO_DataInitTypeDef config;
1148 uint32_t errorstate;
1149 uint32_t add = BlockAdd;
1150
1151 if(NULL == pData)
1152 {
1153 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1154 return HAL_ERROR;
1155 }
1156
1157 if(hsd->State == HAL_SD_STATE_READY)
1158 {
1159 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1160
1161 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1162 {
1163 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1164 return HAL_ERROR;
1165 }
1166
1167 hsd->State = HAL_SD_STATE_BUSY;
1168
1169 /* Initialize data control register */
1170 hsd->Instance->DCTRL = 0U;
1171
1172 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1173
1174 /* Set the DMA transfer complete callback */
1175 hsd->hdmarx->XferCpltCallback = SD_DMAReceiveCplt;
1176
1177 /* Set the DMA error callback */
1178 hsd->hdmarx->XferErrorCallback = SD_DMAError;
1179
1180 /* Set the DMA Abort callback */
1181 hsd->hdmarx->XferAbortCallback = NULL;
1182
1183 /* Force DMA Direction */
1184 hsd->hdmarx->Init.Direction = DMA_PERIPH_TO_MEMORY;
1185 MODIFY_REG(hsd->hdmarx->Instance->CCR, DMA_CCR_DIR, hsd->hdmarx->Init.Direction);
1186
1187 /* Enable the DMA Channel */
1188 if(HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pData, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1189 {
1190 __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1191 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1192 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1193 hsd->State = HAL_SD_STATE_READY;
1194 return HAL_ERROR;
1195 }
1196 else
1197 {
1198 /* Enable SD DMA transfer */
1199 __HAL_SD_DMA_ENABLE(hsd);
1200
1201 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1202 {
1203 add *= 512U;
1204 }
1205
1206 /* Configure the SD DPSM (Data Path State Machine) */
1207 config.DataTimeOut = SDMMC_DATATIMEOUT;
1208 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1209 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1210 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1211 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1212 config.DPSM = SDIO_DPSM_ENABLE;
1213 (void)SDIO_ConfigData(hsd->Instance, &config);
1214
1215 /* Read Blocks in DMA mode */
1216 if(NumberOfBlocks > 1U)
1217 {
1218 hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1219
1220 /* Read Multi Block command */
1221 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1222 }
1223 else
1224 {
1225 hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
1226
1227 /* Read Single Block command */
1228 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1229 }
1230 if(errorstate != HAL_SD_ERROR_NONE)
1231 {
1232 /* Clear all the static flags */
1233 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1234 hsd->ErrorCode |= errorstate;
1235 hsd->State = HAL_SD_STATE_READY;
1236 hsd->Context = SD_CONTEXT_NONE;
1237 return HAL_ERROR;
1238 }
1239
1240 return HAL_OK;
1241 }
1242 }
1243 else
1244 {
1245 return HAL_BUSY;
1246 }
1247 }
1248
1249 /**
1250 * @brief Writes block(s) to a specified address in a card. The Data transfer
1251 * is managed by DMA mode.
1252 * @note This API should be followed by a check on the card state through
1253 * HAL_SD_GetCardState().
1254 * @note You could also check the DMA transfer process through the SD Tx
1255 * interrupt event.
1256 * @param hsd: Pointer to SD handle
1257 * @param pData: Pointer to the buffer that will contain the data to transmit
1258 * @param BlockAdd: Block Address where data will be written
1259 * @param NumberOfBlocks: Number of blocks to write
1260 * @retval HAL status
1261 */
HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef * hsd,uint8_t * pData,uint32_t BlockAdd,uint32_t NumberOfBlocks)1262 HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1263 {
1264 SDIO_DataInitTypeDef config;
1265 uint32_t errorstate;
1266 uint32_t add = BlockAdd;
1267
1268 if(NULL == pData)
1269 {
1270 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1271 return HAL_ERROR;
1272 }
1273
1274 if(hsd->State == HAL_SD_STATE_READY)
1275 {
1276 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1277
1278 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1279 {
1280 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1281 return HAL_ERROR;
1282 }
1283
1284 hsd->State = HAL_SD_STATE_BUSY;
1285
1286 /* Initialize data control register */
1287 hsd->Instance->DCTRL = 0U;
1288
1289 /* Enable SD Error interrupts */
1290 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
1291
1292 /* Set the DMA transfer complete callback */
1293 hsd->hdmatx->XferCpltCallback = SD_DMATransmitCplt;
1294
1295 /* Set the DMA error callback */
1296 hsd->hdmatx->XferErrorCallback = SD_DMAError;
1297
1298 /* Set the DMA Abort callback */
1299 hsd->hdmatx->XferAbortCallback = NULL;
1300
1301 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1302 {
1303 add *= 512U;
1304 }
1305
1306 /* Write Blocks in Polling mode */
1307 if(NumberOfBlocks > 1U)
1308 {
1309 hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1310
1311 /* Write Multi Block command */
1312 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1313 }
1314 else
1315 {
1316 hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
1317
1318 /* Write Single Block command */
1319 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1320 }
1321 if(errorstate != HAL_SD_ERROR_NONE)
1322 {
1323 /* Clear all the static flags */
1324 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1325 hsd->ErrorCode |= errorstate;
1326 hsd->State = HAL_SD_STATE_READY;
1327 hsd->Context = SD_CONTEXT_NONE;
1328 return HAL_ERROR;
1329 }
1330
1331 /* Enable SDIO DMA transfer */
1332 __HAL_SD_DMA_ENABLE(hsd);
1333
1334 /* Force DMA Direction */
1335 hsd->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;
1336 MODIFY_REG(hsd->hdmatx->Instance->CCR, DMA_CCR_DIR, hsd->hdmatx->Init.Direction);
1337
1338 /* Enable the DMA Channel */
1339 if(HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pData, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1340 {
1341 __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
1342 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1343 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1344 hsd->State = HAL_SD_STATE_READY;
1345 hsd->Context = SD_CONTEXT_NONE;
1346 return HAL_ERROR;
1347 }
1348 else
1349 {
1350 /* Configure the SD DPSM (Data Path State Machine) */
1351 config.DataTimeOut = SDMMC_DATATIMEOUT;
1352 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1353 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1354 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1355 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1356 config.DPSM = SDIO_DPSM_ENABLE;
1357 (void)SDIO_ConfigData(hsd->Instance, &config);
1358
1359 return HAL_OK;
1360 }
1361 }
1362 else
1363 {
1364 return HAL_BUSY;
1365 }
1366 }
1367
1368 /**
1369 * @brief Erases the specified memory area of the given SD card.
1370 * @note This API should be followed by a check on the card state through
1371 * HAL_SD_GetCardState().
1372 * @param hsd: Pointer to SD handle
1373 * @param BlockStartAdd: Start Block address
1374 * @param BlockEndAdd: End Block address
1375 * @retval HAL status
1376 */
HAL_SD_Erase(SD_HandleTypeDef * hsd,uint32_t BlockStartAdd,uint32_t BlockEndAdd)1377 HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
1378 {
1379 uint32_t errorstate;
1380 uint32_t start_add = BlockStartAdd;
1381 uint32_t end_add = BlockEndAdd;
1382
1383 if(hsd->State == HAL_SD_STATE_READY)
1384 {
1385 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1386
1387 if(end_add < start_add)
1388 {
1389 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1390 return HAL_ERROR;
1391 }
1392
1393 if(end_add > (hsd->SdCard.LogBlockNbr))
1394 {
1395 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1396 return HAL_ERROR;
1397 }
1398
1399 hsd->State = HAL_SD_STATE_BUSY;
1400
1401 /* Check if the card command class supports erase command */
1402 if(((hsd->SdCard.Class) & SDIO_CCCC_ERASE) == 0U)
1403 {
1404 /* Clear all the static flags */
1405 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1406 hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
1407 hsd->State = HAL_SD_STATE_READY;
1408 return HAL_ERROR;
1409 }
1410
1411 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
1412 {
1413 /* Clear all the static flags */
1414 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1415 hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
1416 hsd->State = HAL_SD_STATE_READY;
1417 return HAL_ERROR;
1418 }
1419
1420 /* Get start and end block for high capacity cards */
1421 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1422 {
1423 start_add *= 512U;
1424 end_add *= 512U;
1425 }
1426
1427 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1428 if(hsd->SdCard.CardType != CARD_SECURED)
1429 {
1430 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
1431 errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
1432 if(errorstate != HAL_SD_ERROR_NONE)
1433 {
1434 /* Clear all the static flags */
1435 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1436 hsd->ErrorCode |= errorstate;
1437 hsd->State = HAL_SD_STATE_READY;
1438 return HAL_ERROR;
1439 }
1440
1441 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
1442 errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
1443 if(errorstate != HAL_SD_ERROR_NONE)
1444 {
1445 /* Clear all the static flags */
1446 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1447 hsd->ErrorCode |= errorstate;
1448 hsd->State = HAL_SD_STATE_READY;
1449 return HAL_ERROR;
1450 }
1451 }
1452
1453 /* Send CMD38 ERASE */
1454 errorstate = SDMMC_CmdErase(hsd->Instance);
1455 if(errorstate != HAL_SD_ERROR_NONE)
1456 {
1457 /* Clear all the static flags */
1458 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1459 hsd->ErrorCode |= errorstate;
1460 hsd->State = HAL_SD_STATE_READY;
1461 return HAL_ERROR;
1462 }
1463
1464 hsd->State = HAL_SD_STATE_READY;
1465
1466 return HAL_OK;
1467 }
1468 else
1469 {
1470 return HAL_BUSY;
1471 }
1472 }
1473
1474 /**
1475 * @brief This function handles SD card interrupt request.
1476 * @param hsd: Pointer to SD handle
1477 * @retval None
1478 */
HAL_SD_IRQHandler(SD_HandleTypeDef * hsd)1479 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1480 {
1481 uint32_t errorstate;
1482 uint32_t context = hsd->Context;
1483
1484 /* Check for SDIO interrupt flags */
1485 if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1486 {
1487 SD_Read_IT(hsd);
1488 }
1489
1490 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) != RESET)
1491 {
1492 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DATAEND);
1493
1494 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1495 SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR | SDIO_IT_TXFIFOHE |\
1496 SDIO_IT_RXFIFOHF);
1497
1498 hsd->Instance->DCTRL &= ~(SDIO_DCTRL_DTEN);
1499
1500 if((context & SD_CONTEXT_IT) != 0U)
1501 {
1502 if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1503 {
1504 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1505 if(errorstate != HAL_SD_ERROR_NONE)
1506 {
1507 hsd->ErrorCode |= errorstate;
1508 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1509 hsd->ErrorCallback(hsd);
1510 #else
1511 HAL_SD_ErrorCallback(hsd);
1512 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1513 }
1514 }
1515
1516 /* Clear all the static flags */
1517 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
1518
1519 hsd->State = HAL_SD_STATE_READY;
1520 hsd->Context = SD_CONTEXT_NONE;
1521 if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1522 {
1523 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1524 hsd->RxCpltCallback(hsd);
1525 #else
1526 HAL_SD_RxCpltCallback(hsd);
1527 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1528 }
1529 else
1530 {
1531 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1532 hsd->TxCpltCallback(hsd);
1533 #else
1534 HAL_SD_TxCpltCallback(hsd);
1535 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1536 }
1537 }
1538 else if((context & SD_CONTEXT_DMA) != 0U)
1539 {
1540 if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1541 {
1542 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1543 if(errorstate != HAL_SD_ERROR_NONE)
1544 {
1545 hsd->ErrorCode |= errorstate;
1546 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1547 hsd->ErrorCallback(hsd);
1548 #else
1549 HAL_SD_ErrorCallback(hsd);
1550 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1551 }
1552 }
1553 if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) == 0U) && ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) == 0U))
1554 {
1555 /* Disable the DMA transfer for transmit request by setting the DMAEN bit
1556 in the SD DCTRL register */
1557 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
1558
1559 hsd->State = HAL_SD_STATE_READY;
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
1569 {
1570 /* Nothing to do */
1571 }
1572 }
1573
1574 else if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1575 {
1576 SD_Write_IT(hsd);
1577 }
1578
1579 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR) != RESET)
1580 {
1581 /* Set Error code */
1582 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL) != RESET)
1583 {
1584 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
1585 }
1586 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) != RESET)
1587 {
1588 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1589 }
1590 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR) != RESET)
1591 {
1592 hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
1593 }
1594 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR) != RESET)
1595 {
1596 hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
1597 }
1598
1599 /* Clear All flags */
1600 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS | SDIO_FLAG_STBITERR);
1601
1602 /* Disable all interrupts */
1603 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1604 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1605
1606 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
1607
1608 if((context & SD_CONTEXT_IT) != 0U)
1609 {
1610 /* Set the SD state to ready to be able to start again the process */
1611 hsd->State = HAL_SD_STATE_READY;
1612 hsd->Context = SD_CONTEXT_NONE;
1613 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1614 hsd->ErrorCallback(hsd);
1615 #else
1616 HAL_SD_ErrorCallback(hsd);
1617 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1618 }
1619 else if((context & SD_CONTEXT_DMA) != 0U)
1620 {
1621 /* Abort the SD DMA channel */
1622 if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1623 {
1624 /* Set the DMA Tx abort callback */
1625 hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
1626 /* Abort DMA in IT mode */
1627 if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
1628 {
1629 SD_DMATxAbort(hsd->hdmatx);
1630 }
1631 }
1632 else if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1633 {
1634 /* Set the DMA Rx abort callback */
1635 hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
1636 /* Abort DMA in IT mode */
1637 if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
1638 {
1639 SD_DMARxAbort(hsd->hdmarx);
1640 }
1641 }
1642 else
1643 {
1644 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1645 hsd->State = HAL_SD_STATE_READY;
1646 hsd->Context = SD_CONTEXT_NONE;
1647 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1648 hsd->AbortCpltCallback(hsd);
1649 #else
1650 HAL_SD_AbortCallback(hsd);
1651 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1652 }
1653 }
1654 else
1655 {
1656 /* Nothing to do */
1657 }
1658 }
1659 else
1660 {
1661 /* Nothing to do */
1662 }
1663 }
1664
1665 /**
1666 * @brief return the SD state
1667 * @param hsd: Pointer to sd handle
1668 * @retval HAL state
1669 */
HAL_SD_GetState(SD_HandleTypeDef * hsd)1670 HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
1671 {
1672 return hsd->State;
1673 }
1674
1675 /**
1676 * @brief Return the SD error code
1677 * @param hsd : Pointer to a SD_HandleTypeDef structure that contains
1678 * the configuration information.
1679 * @retval SD Error Code
1680 */
HAL_SD_GetError(SD_HandleTypeDef * hsd)1681 uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
1682 {
1683 return hsd->ErrorCode;
1684 }
1685
1686 /**
1687 * @brief Tx Transfer completed callbacks
1688 * @param hsd: Pointer to SD handle
1689 * @retval None
1690 */
HAL_SD_TxCpltCallback(SD_HandleTypeDef * hsd)1691 __weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
1692 {
1693 /* Prevent unused argument(s) compilation warning */
1694 UNUSED(hsd);
1695
1696 /* NOTE : This function should not be modified, when the callback is needed,
1697 the HAL_SD_TxCpltCallback can be implemented in the user file
1698 */
1699 }
1700
1701 /**
1702 * @brief Rx Transfer completed callbacks
1703 * @param hsd: Pointer SD handle
1704 * @retval None
1705 */
HAL_SD_RxCpltCallback(SD_HandleTypeDef * hsd)1706 __weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
1707 {
1708 /* Prevent unused argument(s) compilation warning */
1709 UNUSED(hsd);
1710
1711 /* NOTE : This function should not be modified, when the callback is needed,
1712 the HAL_SD_RxCpltCallback can be implemented in the user file
1713 */
1714 }
1715
1716 /**
1717 * @brief SD error callbacks
1718 * @param hsd: Pointer SD handle
1719 * @retval None
1720 */
HAL_SD_ErrorCallback(SD_HandleTypeDef * hsd)1721 __weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
1722 {
1723 /* Prevent unused argument(s) compilation warning */
1724 UNUSED(hsd);
1725
1726 /* NOTE : This function should not be modified, when the callback is needed,
1727 the HAL_SD_ErrorCallback can be implemented in the user file
1728 */
1729 }
1730
1731 /**
1732 * @brief SD Abort callbacks
1733 * @param hsd: Pointer SD handle
1734 * @retval None
1735 */
HAL_SD_AbortCallback(SD_HandleTypeDef * hsd)1736 __weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
1737 {
1738 /* Prevent unused argument(s) compilation warning */
1739 UNUSED(hsd);
1740
1741 /* NOTE : This function should not be modified, when the callback is needed,
1742 the HAL_SD_AbortCallback can be implemented in the user file
1743 */
1744 }
1745
1746 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1747 /**
1748 * @brief Register a User SD Callback
1749 * To be used instead of the weak (surcharged) predefined callback
1750 * @param hsd : SD handle
1751 * @param CallbackID : ID of the callback to be registered
1752 * This parameter can be one of the following values:
1753 * @arg @ref HAL_SD_TX_CPLT_CB_ID SD Tx Complete Callback ID
1754 * @arg @ref HAL_SD_RX_CPLT_CB_ID SD Rx Complete Callback ID
1755 * @arg @ref HAL_SD_ERROR_CB_ID SD Error Callback ID
1756 * @arg @ref HAL_SD_ABORT_CB_ID SD Abort Callback ID
1757 * @arg @ref HAL_SD_MSP_INIT_CB_ID SD MspInit Callback ID
1758 * @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
1759 * @param pCallback : pointer to the Callback function
1760 * @retval status
1761 */
HAL_SD_RegisterCallback(SD_HandleTypeDef * hsd,HAL_SD_CallbackIDTypeDef CallbackID,pSD_CallbackTypeDef pCallback)1762 HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
1763 {
1764 HAL_StatusTypeDef status = HAL_OK;
1765
1766 if(pCallback == NULL)
1767 {
1768 /* Update the error code */
1769 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1770 return HAL_ERROR;
1771 }
1772
1773 /* Process locked */
1774 __HAL_LOCK(hsd);
1775
1776 if(hsd->State == HAL_SD_STATE_READY)
1777 {
1778 switch (CallbackID)
1779 {
1780 case HAL_SD_TX_CPLT_CB_ID :
1781 hsd->TxCpltCallback = pCallback;
1782 break;
1783 case HAL_SD_RX_CPLT_CB_ID :
1784 hsd->RxCpltCallback = pCallback;
1785 break;
1786 case HAL_SD_ERROR_CB_ID :
1787 hsd->ErrorCallback = pCallback;
1788 break;
1789 case HAL_SD_ABORT_CB_ID :
1790 hsd->AbortCpltCallback = pCallback;
1791 break;
1792 case HAL_SD_MSP_INIT_CB_ID :
1793 hsd->MspInitCallback = pCallback;
1794 break;
1795 case HAL_SD_MSP_DEINIT_CB_ID :
1796 hsd->MspDeInitCallback = pCallback;
1797 break;
1798 default :
1799 /* Update the error code */
1800 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1801 /* update return status */
1802 status = HAL_ERROR;
1803 break;
1804 }
1805 }
1806 else if (hsd->State == HAL_SD_STATE_RESET)
1807 {
1808 switch (CallbackID)
1809 {
1810 case HAL_SD_MSP_INIT_CB_ID :
1811 hsd->MspInitCallback = pCallback;
1812 break;
1813 case HAL_SD_MSP_DEINIT_CB_ID :
1814 hsd->MspDeInitCallback = pCallback;
1815 break;
1816 default :
1817 /* Update the error code */
1818 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1819 /* update return status */
1820 status = HAL_ERROR;
1821 break;
1822 }
1823 }
1824 else
1825 {
1826 /* Update the error code */
1827 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1828 /* update return status */
1829 status = HAL_ERROR;
1830 }
1831
1832 /* Release Lock */
1833 __HAL_UNLOCK(hsd);
1834 return status;
1835 }
1836
1837 /**
1838 * @brief Unregister a User SD Callback
1839 * SD Callback is redirected to the weak (surcharged) predefined callback
1840 * @param hsd : SD handle
1841 * @param CallbackID : ID of the callback to be unregistered
1842 * This parameter can be one of the following values:
1843 * @arg @ref HAL_SD_TX_CPLT_CB_ID SD Tx Complete Callback ID
1844 * @arg @ref HAL_SD_RX_CPLT_CB_ID SD Rx Complete Callback ID
1845 * @arg @ref HAL_SD_ERROR_CB_ID SD Error Callback ID
1846 * @arg @ref HAL_SD_ABORT_CB_ID SD Abort Callback ID
1847 * @arg @ref HAL_SD_MSP_INIT_CB_ID SD MspInit Callback ID
1848 * @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
1849 * @retval status
1850 */
HAL_SD_UnRegisterCallback(SD_HandleTypeDef * hsd,HAL_SD_CallbackIDTypeDef CallbackID)1851 HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
1852 {
1853 HAL_StatusTypeDef status = HAL_OK;
1854
1855 /* Process locked */
1856 __HAL_LOCK(hsd);
1857
1858 if(hsd->State == HAL_SD_STATE_READY)
1859 {
1860 switch (CallbackID)
1861 {
1862 case HAL_SD_TX_CPLT_CB_ID :
1863 hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
1864 break;
1865 case HAL_SD_RX_CPLT_CB_ID :
1866 hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
1867 break;
1868 case HAL_SD_ERROR_CB_ID :
1869 hsd->ErrorCallback = HAL_SD_ErrorCallback;
1870 break;
1871 case HAL_SD_ABORT_CB_ID :
1872 hsd->AbortCpltCallback = HAL_SD_AbortCallback;
1873 break;
1874 case HAL_SD_MSP_INIT_CB_ID :
1875 hsd->MspInitCallback = HAL_SD_MspInit;
1876 break;
1877 case HAL_SD_MSP_DEINIT_CB_ID :
1878 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
1879 break;
1880 default :
1881 /* Update the error code */
1882 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1883 /* update return status */
1884 status = HAL_ERROR;
1885 break;
1886 }
1887 }
1888 else if (hsd->State == HAL_SD_STATE_RESET)
1889 {
1890 switch (CallbackID)
1891 {
1892 case HAL_SD_MSP_INIT_CB_ID :
1893 hsd->MspInitCallback = HAL_SD_MspInit;
1894 break;
1895 case HAL_SD_MSP_DEINIT_CB_ID :
1896 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
1897 break;
1898 default :
1899 /* Update the error code */
1900 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1901 /* update return status */
1902 status = HAL_ERROR;
1903 break;
1904 }
1905 }
1906 else
1907 {
1908 /* Update the error code */
1909 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1910 /* update return status */
1911 status = HAL_ERROR;
1912 }
1913
1914 /* Release Lock */
1915 __HAL_UNLOCK(hsd);
1916 return status;
1917 }
1918 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1919
1920 /**
1921 * @}
1922 */
1923
1924 /** @addtogroup SD_Exported_Functions_Group3
1925 * @brief management functions
1926 *
1927 @verbatim
1928 ==============================================================================
1929 ##### Peripheral Control functions #####
1930 ==============================================================================
1931 [..]
1932 This subsection provides a set of functions allowing to control the SD card
1933 operations and get the related information
1934
1935 @endverbatim
1936 * @{
1937 */
1938
1939 /**
1940 * @brief Returns information the information of the card which are stored on
1941 * the CID register.
1942 * @param hsd: Pointer to SD handle
1943 * @param pCID: Pointer to a HAL_SD_CardCIDTypeDef structure that
1944 * contains all CID register parameters
1945 * @retval HAL status
1946 */
HAL_SD_GetCardCID(SD_HandleTypeDef * hsd,HAL_SD_CardCIDTypeDef * pCID)1947 HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
1948 {
1949 pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U);
1950
1951 pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U);
1952
1953 pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U));
1954
1955 pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU);
1956
1957 pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U);
1958
1959 pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U));
1960
1961 pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U);
1962
1963 pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U);
1964
1965 pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U);
1966
1967 pCID->Reserved2 = 1U;
1968
1969 return HAL_OK;
1970 }
1971
1972 /**
1973 * @brief Returns information the information of the card which are stored on
1974 * the CSD register.
1975 * @param hsd: Pointer to SD handle
1976 * @param pCSD: Pointer to a HAL_SD_CardCSDTypeDef structure that
1977 * contains all CSD register parameters
1978 * @retval HAL status
1979 */
HAL_SD_GetCardCSD(SD_HandleTypeDef * hsd,HAL_SD_CardCSDTypeDef * pCSD)1980 HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
1981 {
1982 pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U);
1983
1984 pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U);
1985
1986 pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U);
1987
1988 pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U);
1989
1990 pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U);
1991
1992 pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU);
1993
1994 pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U);
1995
1996 pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U);
1997
1998 pCSD->PartBlockRead = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U);
1999
2000 pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U);
2001
2002 pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U);
2003
2004 pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U);
2005
2006 pCSD->Reserved2 = 0U; /*!< Reserved */
2007
2008 if(hsd->SdCard.CardType == CARD_SDSC)
2009 {
2010 pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U));
2011
2012 pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U);
2013
2014 pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U);
2015
2016 pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U);
2017
2018 pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U);
2019
2020 pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U);
2021
2022 hsd->SdCard.BlockNbr = (pCSD->DeviceSize + 1U) ;
2023 hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
2024 hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
2025
2026 hsd->SdCard.LogBlockNbr = (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U);
2027 hsd->SdCard.LogBlockSize = 512U;
2028 }
2029 else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)
2030 {
2031 /* Byte 7 */
2032 pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U));
2033
2034 hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U);
2035 hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr;
2036 hsd->SdCard.BlockSize = 512U;
2037 hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize;
2038 }
2039 else
2040 {
2041 /* Clear all the static flags */
2042 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2043 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2044 hsd->State = HAL_SD_STATE_READY;
2045 return HAL_ERROR;
2046 }
2047
2048 pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U);
2049
2050 pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U);
2051
2052 pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU);
2053
2054 pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U);
2055
2056 pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U);
2057
2058 pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U);
2059
2060 pCSD->MaxWrBlockLen= (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U);
2061
2062 pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U);
2063
2064 pCSD->Reserved3 = 0;
2065
2066 pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U);
2067
2068 pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U);
2069
2070 pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U);
2071
2072 pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U);
2073
2074 pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U);
2075
2076 pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U);
2077
2078 pCSD->ECC= (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U);
2079
2080 pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U);
2081
2082 pCSD->Reserved4 = 1;
2083
2084 return HAL_OK;
2085 }
2086
2087 /**
2088 * @brief Gets the SD status info.
2089 * @param hsd: Pointer to SD handle
2090 * @param pStatus: Pointer to the HAL_SD_CardStatusTypeDef structure that
2091 * will contain the SD card status information
2092 * @retval HAL status
2093 */
HAL_SD_GetCardStatus(SD_HandleTypeDef * hsd,HAL_SD_CardStatusTypeDef * pStatus)2094 HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
2095 {
2096 uint32_t sd_status[16];
2097 uint32_t errorstate;
2098 HAL_StatusTypeDef status = HAL_OK;
2099
2100 errorstate = SD_SendSDStatus(hsd, sd_status);
2101 if(errorstate != HAL_SD_ERROR_NONE)
2102 {
2103 /* Clear all the static flags */
2104 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2105 hsd->ErrorCode |= errorstate;
2106 hsd->State = HAL_SD_STATE_READY;
2107 status = HAL_ERROR;
2108 }
2109 else
2110 {
2111 pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U);
2112
2113 pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U);
2114
2115 pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U));
2116
2117 pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U) | ((sd_status[1] & 0xFF00U) << 8U) |
2118 ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U));
2119
2120 pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU);
2121
2122 pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U);
2123
2124 pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U);
2125
2126 pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU));
2127
2128 pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U);
2129
2130 pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U);
2131 }
2132
2133 /* Set Block Size for Card */
2134 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
2135 if(errorstate != HAL_SD_ERROR_NONE)
2136 {
2137 /* Clear all the static flags */
2138 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2139 hsd->ErrorCode = errorstate;
2140 hsd->State = HAL_SD_STATE_READY;
2141 status = HAL_ERROR;
2142 }
2143
2144 return status;
2145 }
2146
2147 /**
2148 * @brief Gets the SD card info.
2149 * @param hsd: Pointer to SD handle
2150 * @param pCardInfo: Pointer to the HAL_SD_CardInfoTypeDef structure that
2151 * will contain the SD card status information
2152 * @retval HAL status
2153 */
HAL_SD_GetCardInfo(SD_HandleTypeDef * hsd,HAL_SD_CardInfoTypeDef * pCardInfo)2154 HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
2155 {
2156 pCardInfo->CardType = (uint32_t)(hsd->SdCard.CardType);
2157 pCardInfo->CardVersion = (uint32_t)(hsd->SdCard.CardVersion);
2158 pCardInfo->Class = (uint32_t)(hsd->SdCard.Class);
2159 pCardInfo->RelCardAdd = (uint32_t)(hsd->SdCard.RelCardAdd);
2160 pCardInfo->BlockNbr = (uint32_t)(hsd->SdCard.BlockNbr);
2161 pCardInfo->BlockSize = (uint32_t)(hsd->SdCard.BlockSize);
2162 pCardInfo->LogBlockNbr = (uint32_t)(hsd->SdCard.LogBlockNbr);
2163 pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);
2164
2165 return HAL_OK;
2166 }
2167
2168 /**
2169 * @brief Enables wide bus operation for the requested card if supported by
2170 * card.
2171 * @param hsd: Pointer to SD handle
2172 * @param WideMode: Specifies the SD card wide bus mode
2173 * This parameter can be one of the following values:
2174 * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer
2175 * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
2176 * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
2177 * @retval HAL status
2178 */
HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef * hsd,uint32_t WideMode)2179 HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
2180 {
2181 SDIO_InitTypeDef Init;
2182 uint32_t errorstate;
2183 HAL_StatusTypeDef status = HAL_OK;
2184
2185 /* Check the parameters */
2186 assert_param(IS_SDIO_BUS_WIDE(WideMode));
2187
2188 /* Change State */
2189 hsd->State = HAL_SD_STATE_BUSY;
2190
2191 if(hsd->SdCard.CardType != CARD_SECURED)
2192 {
2193 if(WideMode == SDIO_BUS_WIDE_8B)
2194 {
2195 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2196 }
2197 else if(WideMode == SDIO_BUS_WIDE_4B)
2198 {
2199 errorstate = SD_WideBus_Enable(hsd);
2200
2201 hsd->ErrorCode |= errorstate;
2202 }
2203 else if(WideMode == SDIO_BUS_WIDE_1B)
2204 {
2205 errorstate = SD_WideBus_Disable(hsd);
2206
2207 hsd->ErrorCode |= errorstate;
2208 }
2209 else
2210 {
2211 /* WideMode is not a valid argument*/
2212 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2213 }
2214 }
2215 else
2216 {
2217 /* MMC Card does not support this feature */
2218 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2219 }
2220
2221 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2222 {
2223 /* Clear all the static flags */
2224 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2225 hsd->State = HAL_SD_STATE_READY;
2226 status = HAL_ERROR;
2227 }
2228 else
2229 {
2230 /* Configure the SDIO peripheral */
2231 Init.ClockEdge = hsd->Init.ClockEdge;
2232 Init.ClockBypass = hsd->Init.ClockBypass;
2233 Init.ClockPowerSave = hsd->Init.ClockPowerSave;
2234 Init.BusWide = WideMode;
2235 Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;
2236 Init.ClockDiv = hsd->Init.ClockDiv;
2237 (void)SDIO_Init(hsd->Instance, Init);
2238 }
2239
2240 /* Set Block Size for Card */
2241 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
2242 if(errorstate != HAL_SD_ERROR_NONE)
2243 {
2244 /* Clear all the static flags */
2245 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2246 hsd->ErrorCode |= errorstate;
2247 status = HAL_ERROR;
2248 }
2249
2250 /* Change State */
2251 hsd->State = HAL_SD_STATE_READY;
2252
2253 return status;
2254 }
2255
2256 /**
2257 * @brief Gets the current sd card data state.
2258 * @param hsd: pointer to SD handle
2259 * @retval Card state
2260 */
HAL_SD_GetCardState(SD_HandleTypeDef * hsd)2261 HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
2262 {
2263 uint32_t cardstate;
2264 uint32_t errorstate;
2265 uint32_t resp1 = 0;
2266
2267 errorstate = SD_SendStatus(hsd, &resp1);
2268 if(errorstate != HAL_SD_ERROR_NONE)
2269 {
2270 hsd->ErrorCode |= errorstate;
2271 }
2272
2273 cardstate = ((resp1 >> 9U) & 0x0FU);
2274
2275 return (HAL_SD_CardStateTypeDef)cardstate;
2276 }
2277
2278 /**
2279 * @brief Abort the current transfer and disable the SD.
2280 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
2281 * the configuration information for SD module.
2282 * @retval HAL status
2283 */
HAL_SD_Abort(SD_HandleTypeDef * hsd)2284 HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
2285 {
2286 HAL_SD_CardStateTypeDef CardState;
2287 uint32_t context = hsd->Context;
2288
2289 /* DIsable All interrupts */
2290 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2291 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2292
2293 /* Clear All flags */
2294 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2295
2296 CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
2297
2298 if ((context & SD_CONTEXT_DMA) != 0U)
2299 {
2300 /* Disable the SD DMA request */
2301 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2302
2303 /* Abort the SD DMA Tx channel */
2304 if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
2305 {
2306 if(HAL_DMA_Abort(hsd->hdmatx) != HAL_OK)
2307 {
2308 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2309 }
2310 }
2311 /* Abort the SD DMA Rx channel */
2312 else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
2313 {
2314 if(HAL_DMA_Abort(hsd->hdmarx) != HAL_OK)
2315 {
2316 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2317 }
2318 }
2319 else
2320 {
2321 /* Nothing to do */
2322 }
2323 }
2324
2325 hsd->State = HAL_SD_STATE_READY;
2326
2327 /* Initialize the SD operation */
2328 hsd->Context = SD_CONTEXT_NONE;
2329
2330 CardState = HAL_SD_GetCardState(hsd);
2331 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2332 {
2333 hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2334 }
2335 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2336 {
2337 return HAL_ERROR;
2338 }
2339 return HAL_OK;
2340 }
2341
2342 /**
2343 * @brief Abort the current transfer and disable the SD (IT mode).
2344 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
2345 * the configuration information for SD module.
2346 * @retval HAL status
2347 */
HAL_SD_Abort_IT(SD_HandleTypeDef * hsd)2348 HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
2349 {
2350 HAL_SD_CardStateTypeDef CardState;
2351 uint32_t context = hsd->Context;
2352
2353 /* Disable All interrupts */
2354 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2355 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2356
2357 CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
2358
2359 if ((context & SD_CONTEXT_DMA) != 0U)
2360 {
2361 /* Disable the SD DMA request */
2362 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2363
2364 /* Abort the SD DMA Tx channel */
2365 if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
2366 {
2367 hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
2368 if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
2369 {
2370 hsd->hdmatx = NULL;
2371 }
2372 }
2373 /* Abort the SD DMA Rx channel */
2374 else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
2375 {
2376 hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
2377 if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
2378 {
2379 hsd->hdmarx = NULL;
2380 }
2381 }
2382 else
2383 {
2384 /* Nothing to do */
2385 }
2386 }
2387 /* No transfer ongoing on both DMA channels*/
2388 else
2389 {
2390 /* Clear All flags */
2391 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2392
2393 CardState = HAL_SD_GetCardState(hsd);
2394 hsd->State = HAL_SD_STATE_READY;
2395 hsd->Context = SD_CONTEXT_NONE;
2396 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2397 {
2398 hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2399 }
2400 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2401 {
2402 return HAL_ERROR;
2403 }
2404 else
2405 {
2406 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2407 hsd->AbortCpltCallback(hsd);
2408 #else
2409 HAL_SD_AbortCallback(hsd);
2410 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2411 }
2412 }
2413
2414 return HAL_OK;
2415 }
2416
2417 /**
2418 * @}
2419 */
2420
2421 /**
2422 * @}
2423 */
2424
2425 /* Private function ----------------------------------------------------------*/
2426 /** @addtogroup SD_Private_Functions
2427 * @{
2428 */
2429
2430 /**
2431 * @brief DMA SD transmit process complete callback
2432 * @param hdma: DMA handle
2433 * @retval None
2434 */
SD_DMATransmitCplt(DMA_HandleTypeDef * hdma)2435 static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
2436 {
2437 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2438
2439 /* Enable DATAEND Interrupt */
2440 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DATAEND));
2441 }
2442
2443 /**
2444 * @brief DMA SD receive process complete callback
2445 * @param hdma: DMA handle
2446 * @retval None
2447 */
SD_DMAReceiveCplt(DMA_HandleTypeDef * hdma)2448 static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
2449 {
2450 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2451 uint32_t errorstate;
2452
2453 /* Send stop command in multiblock write */
2454 if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))
2455 {
2456 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
2457 if(errorstate != HAL_SD_ERROR_NONE)
2458 {
2459 hsd->ErrorCode |= errorstate;
2460 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2461 hsd->ErrorCallback(hsd);
2462 #else
2463 HAL_SD_ErrorCallback(hsd);
2464 #endif
2465 }
2466 }
2467
2468 /* Disable the DMA transfer for transmit request by setting the DMAEN bit
2469 in the SD DCTRL register */
2470 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2471
2472 /* Clear all the static flags */
2473 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2474
2475 hsd->State = HAL_SD_STATE_READY;
2476 hsd->Context = SD_CONTEXT_NONE;
2477
2478 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2479 hsd->RxCpltCallback(hsd);
2480 #else
2481 HAL_SD_RxCpltCallback(hsd);
2482 #endif
2483 }
2484
2485 /**
2486 * @brief DMA SD communication error callback
2487 * @param hdma: DMA handle
2488 * @retval None
2489 */
SD_DMAError(DMA_HandleTypeDef * hdma)2490 static void SD_DMAError(DMA_HandleTypeDef *hdma)
2491 {
2492 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2493 HAL_SD_CardStateTypeDef CardState;
2494 uint32_t RxErrorCode, TxErrorCode;
2495
2496 RxErrorCode = hsd->hdmarx->ErrorCode;
2497 TxErrorCode = hsd->hdmatx->ErrorCode;
2498 if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
2499 {
2500 /* Clear All flags */
2501 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2502
2503 /* Disable All interrupts */
2504 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2505 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2506
2507 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2508 CardState = HAL_SD_GetCardState(hsd);
2509 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2510 {
2511 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2512 }
2513
2514 hsd->State= HAL_SD_STATE_READY;
2515 hsd->Context = SD_CONTEXT_NONE;
2516 }
2517
2518 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2519 hsd->ErrorCallback(hsd);
2520 #else
2521 HAL_SD_ErrorCallback(hsd);
2522 #endif
2523 }
2524
2525 /**
2526 * @brief DMA SD Tx Abort callback
2527 * @param hdma: DMA handle
2528 * @retval None
2529 */
SD_DMATxAbort(DMA_HandleTypeDef * hdma)2530 static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
2531 {
2532 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2533 HAL_SD_CardStateTypeDef CardState;
2534
2535 /* Clear All flags */
2536 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2537
2538 CardState = HAL_SD_GetCardState(hsd);
2539 hsd->State = HAL_SD_STATE_READY;
2540 hsd->Context = SD_CONTEXT_NONE;
2541 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2542 {
2543 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2544 }
2545
2546 if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
2547 {
2548 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2549 hsd->AbortCpltCallback(hsd);
2550 #else
2551 HAL_SD_AbortCallback(hsd);
2552 #endif
2553 }
2554 else
2555 {
2556 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2557 hsd->ErrorCallback(hsd);
2558 #else
2559 HAL_SD_ErrorCallback(hsd);
2560 #endif
2561 }
2562 }
2563
2564 /**
2565 * @brief DMA SD Rx Abort callback
2566 * @param hdma: DMA handle
2567 * @retval None
2568 */
SD_DMARxAbort(DMA_HandleTypeDef * hdma)2569 static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
2570 {
2571 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2572 HAL_SD_CardStateTypeDef CardState;
2573
2574 /* Clear All flags */
2575 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2576
2577 CardState = HAL_SD_GetCardState(hsd);
2578 hsd->State = HAL_SD_STATE_READY;
2579 hsd->Context = SD_CONTEXT_NONE;
2580 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2581 {
2582 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2583 }
2584
2585 if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
2586 {
2587 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2588 hsd->AbortCpltCallback(hsd);
2589 #else
2590 HAL_SD_AbortCallback(hsd);
2591 #endif
2592 }
2593 else
2594 {
2595 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2596 hsd->ErrorCallback(hsd);
2597 #else
2598 HAL_SD_ErrorCallback(hsd);
2599 #endif
2600 }
2601 }
2602
2603 /**
2604 * @brief Initializes the sd card.
2605 * @param hsd: Pointer to SD handle
2606 * @retval SD Card error state
2607 */
SD_InitCard(SD_HandleTypeDef * hsd)2608 static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
2609 {
2610 HAL_SD_CardCSDTypeDef CSD;
2611 uint32_t errorstate;
2612 uint16_t sd_rca = 1U;
2613
2614 /* Check the power State */
2615 if(SDIO_GetPowerState(hsd->Instance) == 0U)
2616 {
2617 /* Power off */
2618 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
2619 }
2620
2621 if(hsd->SdCard.CardType != CARD_SECURED)
2622 {
2623 /* Send CMD2 ALL_SEND_CID */
2624 errorstate = SDMMC_CmdSendCID(hsd->Instance);
2625 if(errorstate != HAL_SD_ERROR_NONE)
2626 {
2627 return errorstate;
2628 }
2629 else
2630 {
2631 /* Get Card identification number data */
2632 hsd->CID[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2633 hsd->CID[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
2634 hsd->CID[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
2635 hsd->CID[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
2636 }
2637 }
2638
2639 if(hsd->SdCard.CardType != CARD_SECURED)
2640 {
2641 /* Send CMD3 SET_REL_ADDR with argument 0 */
2642 /* SD Card publishes its RCA. */
2643 errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
2644 if(errorstate != HAL_SD_ERROR_NONE)
2645 {
2646 return errorstate;
2647 }
2648 }
2649 if(hsd->SdCard.CardType != CARD_SECURED)
2650 {
2651 /* Get the SD card RCA */
2652 hsd->SdCard.RelCardAdd = sd_rca;
2653
2654 /* Send CMD9 SEND_CSD with argument as card's RCA */
2655 errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2656 if(errorstate != HAL_SD_ERROR_NONE)
2657 {
2658 return errorstate;
2659 }
2660 else
2661 {
2662 /* Get Card Specific Data */
2663 hsd->CSD[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2664 hsd->CSD[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
2665 hsd->CSD[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
2666 hsd->CSD[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
2667 }
2668 }
2669
2670 /* Get the Card Class */
2671 hsd->SdCard.Class = (SDIO_GetResponse(hsd->Instance, SDIO_RESP2) >> 20U);
2672
2673 /* Get CSD parameters */
2674 if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
2675 {
2676 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2677 }
2678
2679 /* Select the Card */
2680 errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
2681 if(errorstate != HAL_SD_ERROR_NONE)
2682 {
2683 return errorstate;
2684 }
2685
2686 /* Configure SDIO peripheral interface */
2687 (void)SDIO_Init(hsd->Instance, hsd->Init);
2688
2689 /* All cards are initialized */
2690 return HAL_SD_ERROR_NONE;
2691 }
2692
2693 /**
2694 * @brief Enquires cards about their operating voltage and configures clock
2695 * controls and stores SD information that will be needed in future
2696 * in the SD handle.
2697 * @param hsd: Pointer to SD handle
2698 * @retval error state
2699 */
SD_PowerON(SD_HandleTypeDef * hsd)2700 static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
2701 {
2702 __IO uint32_t count = 0U;
2703 uint32_t response = 0U, validvoltage = 0U;
2704 uint32_t errorstate;
2705
2706 /* CMD0: GO_IDLE_STATE */
2707 errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2708 if(errorstate != HAL_SD_ERROR_NONE)
2709 {
2710 return errorstate;
2711 }
2712
2713 /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
2714 errorstate = SDMMC_CmdOperCond(hsd->Instance);
2715 if(errorstate != HAL_SD_ERROR_NONE)
2716 {
2717 hsd->SdCard.CardVersion = CARD_V1_X;
2718 /* CMD0: GO_IDLE_STATE */
2719 errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2720 if(errorstate != HAL_SD_ERROR_NONE)
2721 {
2722 return errorstate;
2723 }
2724
2725 }
2726 else
2727 {
2728 hsd->SdCard.CardVersion = CARD_V2_X;
2729 }
2730
2731 if( hsd->SdCard.CardVersion == CARD_V2_X)
2732 {
2733 /* SEND CMD55 APP_CMD with RCA as 0 */
2734 errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2735 if(errorstate != HAL_SD_ERROR_NONE)
2736 {
2737 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2738 }
2739 }
2740 /* SD CARD */
2741 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2742 while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
2743 {
2744 /* SEND CMD55 APP_CMD with RCA as 0 */
2745 errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2746 if(errorstate != HAL_SD_ERROR_NONE)
2747 {
2748 return errorstate;
2749 }
2750
2751 /* Send CMD41 */
2752 errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
2753 if(errorstate != HAL_SD_ERROR_NONE)
2754 {
2755 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2756 }
2757
2758 /* Get command response */
2759 response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2760
2761 /* Get operating voltage*/
2762 validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
2763
2764 count++;
2765 }
2766
2767 if(count >= SDMMC_MAX_VOLT_TRIAL)
2768 {
2769 return HAL_SD_ERROR_INVALID_VOLTRANGE;
2770 }
2771
2772 if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2773 {
2774 hsd->SdCard.CardType = CARD_SDHC_SDXC;
2775 }
2776 else
2777 {
2778 hsd->SdCard.CardType = CARD_SDSC;
2779 }
2780
2781
2782 return HAL_SD_ERROR_NONE;
2783 }
2784
2785 /**
2786 * @brief Turns the SDIO output signals off.
2787 * @param hsd: Pointer to SD handle
2788 * @retval None
2789 */
SD_PowerOFF(SD_HandleTypeDef * hsd)2790 static void SD_PowerOFF(SD_HandleTypeDef *hsd)
2791 {
2792 /* Set Power State to OFF */
2793 (void)SDIO_PowerState_OFF(hsd->Instance);
2794 }
2795
2796 /**
2797 * @brief Send Status info command.
2798 * @param hsd: pointer to SD handle
2799 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
2800 * SD Status register)
2801 * @retval error state
2802 */
SD_SendSDStatus(SD_HandleTypeDef * hsd,uint32_t * pSDstatus)2803 static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
2804 {
2805 SDIO_DataInitTypeDef config;
2806 uint32_t errorstate;
2807 uint32_t tickstart = HAL_GetTick();
2808 uint32_t count;
2809 uint32_t *pData = pSDstatus;
2810
2811 /* Check SD response */
2812 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
2813 {
2814 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
2815 }
2816
2817 /* Set block size for card if it is not equal to current block size for card */
2818 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
2819 if(errorstate != HAL_SD_ERROR_NONE)
2820 {
2821 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2822 return errorstate;
2823 }
2824
2825 /* Send CMD55 */
2826 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2827 if(errorstate != HAL_SD_ERROR_NONE)
2828 {
2829 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2830 return errorstate;
2831 }
2832
2833 /* Configure the SD DPSM (Data Path State Machine) */
2834 config.DataTimeOut = SDMMC_DATATIMEOUT;
2835 config.DataLength = 64U;
2836 config.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
2837 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
2838 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
2839 config.DPSM = SDIO_DPSM_ENABLE;
2840 (void)SDIO_ConfigData(hsd->Instance, &config);
2841
2842 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
2843 errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
2844 if(errorstate != HAL_SD_ERROR_NONE)
2845 {
2846 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2847 return errorstate;
2848 }
2849
2850 /* Get status data */
2851 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
2852 {
2853 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2854 {
2855 for(count = 0U; count < 8U; count++)
2856 {
2857 *pData = SDIO_ReadFIFO(hsd->Instance);
2858 pData++;
2859 }
2860 }
2861
2862 if((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT)
2863 {
2864 return HAL_SD_ERROR_TIMEOUT;
2865 }
2866 }
2867
2868 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
2869 {
2870 return HAL_SD_ERROR_DATA_TIMEOUT;
2871 }
2872 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2873 {
2874 return HAL_SD_ERROR_DATA_CRC_FAIL;
2875 }
2876 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2877 {
2878 return HAL_SD_ERROR_RX_OVERRUN;
2879 }
2880 else
2881 {
2882 /* Nothing to do */
2883 }
2884
2885 while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)))
2886 {
2887 *pData = SDIO_ReadFIFO(hsd->Instance);
2888 pData++;
2889
2890 if((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT)
2891 {
2892 return HAL_SD_ERROR_TIMEOUT;
2893 }
2894 }
2895
2896 /* Clear all the static status flags*/
2897 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2898
2899 return HAL_SD_ERROR_NONE;
2900 }
2901
2902 /**
2903 * @brief Returns the current card's status.
2904 * @param hsd: Pointer to SD handle
2905 * @param pCardStatus: pointer to the buffer that will contain the SD card
2906 * status (Card Status register)
2907 * @retval error state
2908 */
SD_SendStatus(SD_HandleTypeDef * hsd,uint32_t * pCardStatus)2909 static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
2910 {
2911 uint32_t errorstate;
2912
2913 if(pCardStatus == NULL)
2914 {
2915 return HAL_SD_ERROR_PARAM;
2916 }
2917
2918 /* Send Status command */
2919 errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2920 if(errorstate != HAL_SD_ERROR_NONE)
2921 {
2922 return errorstate;
2923 }
2924
2925 /* Get SD card status */
2926 *pCardStatus = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2927
2928 return HAL_SD_ERROR_NONE;
2929 }
2930
2931 /**
2932 * @brief Enables the SDIO wide bus mode.
2933 * @param hsd: pointer to SD handle
2934 * @retval error state
2935 */
SD_WideBus_Enable(SD_HandleTypeDef * hsd)2936 static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
2937 {
2938 uint32_t scr[2U] = {0U, 0U};
2939 uint32_t errorstate;
2940
2941 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
2942 {
2943 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
2944 }
2945
2946 /* Get SCR Register */
2947 errorstate = SD_FindSCR(hsd, scr);
2948 if(errorstate != HAL_SD_ERROR_NONE)
2949 {
2950 return errorstate;
2951 }
2952
2953 /* If requested card supports wide bus operation */
2954 if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
2955 {
2956 /* Send CMD55 APP_CMD with argument as card's RCA.*/
2957 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2958 if(errorstate != HAL_SD_ERROR_NONE)
2959 {
2960 return errorstate;
2961 }
2962
2963 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
2964 errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
2965 if(errorstate != HAL_SD_ERROR_NONE)
2966 {
2967 return errorstate;
2968 }
2969
2970 return HAL_SD_ERROR_NONE;
2971 }
2972 else
2973 {
2974 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
2975 }
2976 }
2977
2978 /**
2979 * @brief Disables the SDIO wide bus mode.
2980 * @param hsd: Pointer to SD handle
2981 * @retval error state
2982 */
SD_WideBus_Disable(SD_HandleTypeDef * hsd)2983 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
2984 {
2985 uint32_t scr[2U] = {0U, 0U};
2986 uint32_t errorstate;
2987
2988 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
2989 {
2990 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
2991 }
2992
2993 /* Get SCR Register */
2994 errorstate = SD_FindSCR(hsd, scr);
2995 if(errorstate != HAL_SD_ERROR_NONE)
2996 {
2997 return errorstate;
2998 }
2999
3000 /* If requested card supports 1 bit mode operation */
3001 if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)
3002 {
3003 /* Send CMD55 APP_CMD with argument as card's RCA */
3004 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3005 if(errorstate != HAL_SD_ERROR_NONE)
3006 {
3007 return errorstate;
3008 }
3009
3010 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
3011 errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);
3012 if(errorstate != HAL_SD_ERROR_NONE)
3013 {
3014 return errorstate;
3015 }
3016
3017 return HAL_SD_ERROR_NONE;
3018 }
3019 else
3020 {
3021 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3022 }
3023 }
3024
3025
3026 /**
3027 * @brief Finds the SD card SCR register value.
3028 * @param hsd: Pointer to SD handle
3029 * @param pSCR: pointer to the buffer that will contain the SCR value
3030 * @retval error state
3031 */
SD_FindSCR(SD_HandleTypeDef * hsd,uint32_t * pSCR)3032 static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
3033 {
3034 SDIO_DataInitTypeDef config;
3035 uint32_t errorstate;
3036 uint32_t tickstart = HAL_GetTick();
3037 uint32_t index = 0U;
3038 uint32_t tempscr[2U] = {0U, 0U};
3039 uint32_t *scr = pSCR;
3040
3041 /* Set Block Size To 8 Bytes */
3042 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);
3043 if(errorstate != HAL_SD_ERROR_NONE)
3044 {
3045 return errorstate;
3046 }
3047
3048 /* Send CMD55 APP_CMD with argument as card's RCA */
3049 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));
3050 if(errorstate != HAL_SD_ERROR_NONE)
3051 {
3052 return errorstate;
3053 }
3054
3055 config.DataTimeOut = SDMMC_DATATIMEOUT;
3056 config.DataLength = 8U;
3057 config.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
3058 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
3059 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
3060 config.DPSM = SDIO_DPSM_ENABLE;
3061 (void)SDIO_ConfigData(hsd->Instance, &config);
3062
3063 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
3064 errorstate = SDMMC_CmdSendSCR(hsd->Instance);
3065 if(errorstate != HAL_SD_ERROR_NONE)
3066 {
3067 return errorstate;
3068 }
3069
3070 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT))
3071 {
3072 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
3073 {
3074 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
3075 index++;
3076 }
3077 else if(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXACT))
3078 {
3079 break;
3080 }
3081
3082 if((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT)
3083 {
3084 return HAL_SD_ERROR_TIMEOUT;
3085 }
3086 }
3087
3088 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
3089 {
3090 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
3091
3092 return HAL_SD_ERROR_DATA_TIMEOUT;
3093 }
3094 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
3095 {
3096 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
3097
3098 return HAL_SD_ERROR_DATA_CRC_FAIL;
3099 }
3100 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
3101 {
3102 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
3103
3104 return HAL_SD_ERROR_RX_OVERRUN;
3105 }
3106 else
3107 {
3108 /* No error flag set */
3109 /* Clear all the static flags */
3110 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
3111
3112 *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24) | ((tempscr[1] & SDMMC_8TO15BITS) << 8) |\
3113 ((tempscr[1] & SDMMC_16TO23BITS) >> 8) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24));
3114 scr++;
3115 *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24) | ((tempscr[0] & SDMMC_8TO15BITS) << 8) |\
3116 ((tempscr[0] & SDMMC_16TO23BITS) >> 8) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24));
3117
3118 }
3119
3120 return HAL_SD_ERROR_NONE;
3121 }
3122
3123 /**
3124 * @brief Wrap up reading in non-blocking mode.
3125 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
3126 * the configuration information.
3127 * @retval None
3128 */
SD_Read_IT(SD_HandleTypeDef * hsd)3129 static void SD_Read_IT(SD_HandleTypeDef *hsd)
3130 {
3131 uint32_t count, data, dataremaining;
3132 uint8_t* tmp;
3133
3134 tmp = hsd->pRxBuffPtr;
3135 dataremaining = hsd->RxXferSize;
3136
3137 if (dataremaining > 0U)
3138 {
3139 /* Read data from SDIO Rx FIFO */
3140 for(count = 0U; count < 8U; count++)
3141 {
3142 data = SDIO_ReadFIFO(hsd->Instance);
3143 *tmp = (uint8_t)(data & 0xFFU);
3144 tmp++;
3145 dataremaining--;
3146 *tmp = (uint8_t)((data >> 8U) & 0xFFU);
3147 tmp++;
3148 dataremaining--;
3149 *tmp = (uint8_t)((data >> 16U) & 0xFFU);
3150 tmp++;
3151 dataremaining--;
3152 *tmp = (uint8_t)((data >> 24U) & 0xFFU);
3153 tmp++;
3154 dataremaining--;
3155 }
3156
3157 hsd->pRxBuffPtr = tmp;
3158 hsd->RxXferSize = dataremaining;
3159 }
3160 }
3161
3162 /**
3163 * @brief Wrap up writing in non-blocking mode.
3164 * @param hsd: pointer to a SD_HandleTypeDef structure that contains
3165 * the configuration information.
3166 * @retval None
3167 */
SD_Write_IT(SD_HandleTypeDef * hsd)3168 static void SD_Write_IT(SD_HandleTypeDef *hsd)
3169 {
3170 uint32_t count, data, dataremaining;
3171 uint8_t* tmp;
3172
3173 tmp = hsd->pTxBuffPtr;
3174 dataremaining = hsd->TxXferSize;
3175
3176 if (dataremaining > 0U)
3177 {
3178 /* Write data to SDIO Tx FIFO */
3179 for(count = 0U; count < 8U; count++)
3180 {
3181 data = (uint32_t)(*tmp);
3182 tmp++;
3183 dataremaining--;
3184 data |= ((uint32_t)(*tmp) << 8U);
3185 tmp++;
3186 dataremaining--;
3187 data |= ((uint32_t)(*tmp) << 16U);
3188 tmp++;
3189 dataremaining--;
3190 data |= ((uint32_t)(*tmp) << 24U);
3191 tmp++;
3192 dataremaining--;
3193 (void)SDIO_WriteFIFO(hsd->Instance, &data);
3194 }
3195
3196 hsd->pTxBuffPtr = tmp;
3197 hsd->TxXferSize = dataremaining;
3198 }
3199 }
3200
3201 /**
3202 * @}
3203 */
3204
3205 #endif /* HAL_SD_MODULE_ENABLED */
3206
3207 /**
3208 * @}
3209 */
3210
3211 /**
3212 * @}
3213 */
3214
3215 #endif /* SDIO */
3216
