projects / SCSI2SD-V6.git / blob
? search:


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