6fffb51416f983d368167efeb95f052f0b364f22
[SCSI2SD-V6.git] / STM32CubeMX / 2021 / Drivers / STM32F4xx_HAL_Driver / Src / stm32f4xx_hal_sd.c
1 /**
2   ******************************************************************************
3   * @file    stm32f4xx_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) 2017 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 "stm32f4xx_hal.h"
260
261 #if defined(SDIO)
262
263 /** @addtogroup STM32F4xx_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 #if defined(SDIO_STA_STBITERR)
643     while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
644 #else /* SDIO_STA_STBITERR not defined */
645     while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
646 #endif /* SDIO_STA_STBITERR */
647     {
648       if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))
649       {
650         /* Read data from SDIO Rx FIFO */
651         for(count = 0U; count < 8U; count++)
652         {
653           data = SDIO_ReadFIFO(hsd->Instance);
654           *tempbuff = (uint8_t)(data & 0xFFU);
655           tempbuff++;
656           dataremaining--;
657           *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
658           tempbuff++;
659           dataremaining--;
660           *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
661           tempbuff++;
662           dataremaining--;
663           *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
664           tempbuff++;
665           dataremaining--;
666         }
667       }
668
669       if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
670       {
671         /* Clear all the static flags */
672         __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
673         hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
674         hsd->State= HAL_SD_STATE_READY;
675         hsd->Context = SD_CONTEXT_NONE;
676         return HAL_TIMEOUT;
677       }
678     }
679     
680     /* Send stop transmission command in case of multiblock read */
681     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
682     {
683       if(hsd->SdCard.CardType != CARD_SECURED)
684       {
685         /* Send stop transmission command */
686         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
687         if(errorstate != HAL_SD_ERROR_NONE)
688         {
689           /* Clear all the static flags */
690           __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
691           hsd->ErrorCode |= errorstate;
692           hsd->State = HAL_SD_STATE_READY;
693           hsd->Context = SD_CONTEXT_NONE;
694           return HAL_ERROR;
695         }
696       }
697     }
698
699     /* Get error state */
700     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
701     {
702       /* Clear all the static flags */
703       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
704       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
705       hsd->State = HAL_SD_STATE_READY;
706       hsd->Context = SD_CONTEXT_NONE;
707       return HAL_ERROR;
708     }
709     else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
710     {
711       /* Clear all the static flags */
712       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
713       hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
714       hsd->State = HAL_SD_STATE_READY;
715       hsd->Context = SD_CONTEXT_NONE;
716       return HAL_ERROR;
717     }
718     else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
719     {
720       /* Clear all the static flags */
721       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
722       hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
723       hsd->State = HAL_SD_STATE_READY;
724       hsd->Context = SD_CONTEXT_NONE;
725       return HAL_ERROR;
726     }
727     else
728     {
729       /* Nothing to do */
730     }
731
732     /* Empty FIFO if there is still any data */
733     while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))
734     {
735       data = SDIO_ReadFIFO(hsd->Instance);
736       *tempbuff = (uint8_t)(data & 0xFFU);
737       tempbuff++;
738       dataremaining--;
739       *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
740       tempbuff++;
741       dataremaining--;
742       *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
743       tempbuff++;
744       dataremaining--;
745       *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
746       tempbuff++;
747       dataremaining--;
748
749       if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
750       {
751         /* Clear all the static flags */
752         __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
753         hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
754         hsd->State= HAL_SD_STATE_READY;
755         hsd->Context = SD_CONTEXT_NONE;
756         return HAL_ERROR;
757       }
758     }
759
760     /* Clear all the static flags */
761     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
762
763     hsd->State = HAL_SD_STATE_READY;
764
765     return HAL_OK;
766   }
767   else
768   {
769     hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
770     return HAL_ERROR;
771   }
772 }
773
774 /**
775   * @brief  Allows to write block(s) to a specified address in a card. The Data
776   *         transfer is managed by polling mode.
777   * @note   This API should be followed by a check on the card state through
778   *         HAL_SD_GetCardState().
779   * @param  hsd: Pointer to SD handle
780   * @param  pData: pointer to the buffer that will contain the data to transmit
781   * @param  BlockAdd: Block Address where data will be written
782   * @param  NumberOfBlocks: Number of SD blocks to write
783   * @param  Timeout: Specify timeout value
784   * @retval HAL status
785   */
786 HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
787 {
788   SDIO_DataInitTypeDef config;
789   uint32_t errorstate;
790   uint32_t tickstart = HAL_GetTick();
791   uint32_t count, data, dataremaining;
792   uint32_t add = BlockAdd;
793   uint8_t *tempbuff = pData;
794
795   if(NULL == pData)
796   {
797     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
798     return HAL_ERROR;
799   }
800
801   if(hsd->State == HAL_SD_STATE_READY)
802   {
803     hsd->ErrorCode = HAL_SD_ERROR_NONE;
804
805     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
806     {
807       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
808       return HAL_ERROR;
809     }
810
811     hsd->State = HAL_SD_STATE_BUSY;
812
813     /* Initialize data control register */
814     hsd->Instance->DCTRL = 0U;
815
816     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
817     {
818       add *= 512U;
819     }
820
821     /* Set Block Size for Card */
822     errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
823     if(errorstate != HAL_SD_ERROR_NONE)
824     {
825       /* Clear all the static flags */
826       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
827       hsd->ErrorCode |= errorstate;
828       hsd->State = HAL_SD_STATE_READY;
829       return HAL_ERROR;
830     }
831
832     /* Configure the SD DPSM (Data Path State Machine) */
833     config.DataTimeOut   = SDMMC_DATATIMEOUT;
834     config.DataLength    = NumberOfBlocks * BLOCKSIZE;
835     config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
836     config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
837     config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
838     config.DPSM          = SDIO_DPSM_ENABLE;
839     (void)SDIO_ConfigData(hsd->Instance, &config);
840
841     /* Write Blocks in Polling mode */
842     if(NumberOfBlocks > 1U)
843     {
844       hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
845
846       /* Write Multi Block command */
847       errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
848     }
849     else
850     {
851       hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
852
853       /* Write Single Block command */
854       errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
855     }
856     if(errorstate != HAL_SD_ERROR_NONE)
857     {
858       /* Clear all the static flags */
859       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
860       hsd->ErrorCode |= errorstate;
861       hsd->State = HAL_SD_STATE_READY;
862       hsd->Context = SD_CONTEXT_NONE;
863       return HAL_ERROR;
864     }
865
866     /* Write block(s) in polling mode */
867     dataremaining = config.DataLength;
868 #if defined(SDIO_STA_STBITERR)
869     while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
870 #else /* SDIO_STA_STBITERR not defined */
871     while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
872 #endif /* SDIO_STA_STBITERR */
873     {
874       if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) && (dataremaining > 0U))
875       {
876         /* Write data to SDIO Tx FIFO */
877         for(count = 0U; count < 8U; count++)
878         {
879           data = (uint32_t)(*tempbuff);
880           tempbuff++;
881           dataremaining--;
882           data |= ((uint32_t)(*tempbuff) << 8U);
883           tempbuff++;
884           dataremaining--;
885           data |= ((uint32_t)(*tempbuff) << 16U);
886           tempbuff++;
887           dataremaining--;
888           data |= ((uint32_t)(*tempbuff) << 24U);
889           tempbuff++;
890           dataremaining--;
891           (void)SDIO_WriteFIFO(hsd->Instance, &data);
892         }
893       }
894
895       if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
896       {
897         /* Clear all the static flags */
898         __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
899         hsd->ErrorCode |= errorstate;
900         hsd->State = HAL_SD_STATE_READY;
901         hsd->Context = SD_CONTEXT_NONE;
902         return HAL_TIMEOUT;
903       }
904     }
905
906     /* Send stop transmission command in case of multiblock write */
907     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
908     {
909       if(hsd->SdCard.CardType != CARD_SECURED)
910       {
911         /* Send stop transmission command */
912         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
913         if(errorstate != HAL_SD_ERROR_NONE)
914         {
915           /* Clear all the static flags */
916           __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
917           hsd->ErrorCode |= errorstate;
918           hsd->State = HAL_SD_STATE_READY;
919           hsd->Context = SD_CONTEXT_NONE;
920           return HAL_ERROR;
921         }
922       }
923     }
924
925     /* Get error state */
926     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
927     {
928       /* Clear all the static flags */
929       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
930       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
931       hsd->State = HAL_SD_STATE_READY;
932       hsd->Context = SD_CONTEXT_NONE;
933       return HAL_ERROR;
934     }
935     else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
936     {
937       /* Clear all the static flags */
938       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
939       hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
940       hsd->State = HAL_SD_STATE_READY;
941       hsd->Context = SD_CONTEXT_NONE;
942       return HAL_ERROR;
943     }
944     else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
945     {
946       /* Clear all the static flags */
947       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
948       hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
949       hsd->State = HAL_SD_STATE_READY;
950       hsd->Context = SD_CONTEXT_NONE;
951       return HAL_ERROR;
952     }
953     else
954     {
955       /* Nothing to do */
956     }
957
958     /* Clear all the static flags */
959     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
960
961     hsd->State = HAL_SD_STATE_READY;
962
963     return HAL_OK;
964   }
965   else
966   {
967     hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
968     return HAL_ERROR;
969   }
970 }
971
972 /**
973   * @brief  Reads block(s) from a specified address in a card. The Data transfer
974   *         is managed in interrupt mode.
975   * @note   This API should be followed by a check on the card state through
976   *         HAL_SD_GetCardState().
977   * @note   You could also check the IT transfer process through the SD Rx
978   *         interrupt event.
979   * @param  hsd: Pointer to SD handle
980   * @param  pData: Pointer to the buffer that will contain the received data
981   * @param  BlockAdd: Block Address from where data is to be read
982   * @param  NumberOfBlocks: Number of blocks to read.
983   * @retval HAL status
984   */
985 HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
986 {
987   SDIO_DataInitTypeDef config;
988   uint32_t errorstate;
989   uint32_t add = BlockAdd;
990
991   if(NULL == pData)
992   {
993     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
994     return HAL_ERROR;
995   }
996
997   if(hsd->State == HAL_SD_STATE_READY)
998   {
999     hsd->ErrorCode = HAL_SD_ERROR_NONE;
1000
1001     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1002     {
1003       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1004       return HAL_ERROR;
1005     }
1006
1007     hsd->State = HAL_SD_STATE_BUSY;
1008
1009     /* Initialize data control register */
1010     hsd->Instance->DCTRL = 0U;
1011
1012     hsd->pRxBuffPtr = pData;
1013     hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
1014
1015 #if defined(SDIO_STA_STBITERR)
1016     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF | SDIO_IT_STBITERR));
1017 #else /* SDIO_STA_STBITERR not defined */
1018     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF));
1019 #endif /* SDIO_STA_STBITERR */
1020
1021     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1022     {
1023       add *= 512U;
1024     }
1025
1026     /* Set Block Size for Card */
1027     errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1028     if(errorstate != HAL_SD_ERROR_NONE)
1029     {
1030       /* Clear all the static flags */
1031       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1032       hsd->ErrorCode |= errorstate;
1033       hsd->State = HAL_SD_STATE_READY;
1034       return HAL_ERROR;
1035     }
1036
1037     /* Configure the SD DPSM (Data Path State Machine) */
1038     config.DataTimeOut   = SDMMC_DATATIMEOUT;
1039     config.DataLength    = BLOCKSIZE * NumberOfBlocks;
1040     config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1041     config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
1042     config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1043     config.DPSM          = SDIO_DPSM_ENABLE;
1044     (void)SDIO_ConfigData(hsd->Instance, &config);
1045
1046     /* Read Blocks in IT mode */
1047     if(NumberOfBlocks > 1U)
1048     {
1049       hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);
1050
1051       /* Read Multi Block command */
1052       errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1053     }
1054     else
1055     {
1056       hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);
1057
1058       /* Read Single Block command */
1059       errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1060     }
1061     if(errorstate != HAL_SD_ERROR_NONE)
1062     {
1063       /* Clear all the static flags */
1064       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1065       hsd->ErrorCode |= errorstate;
1066       hsd->State = HAL_SD_STATE_READY;
1067       hsd->Context = SD_CONTEXT_NONE;
1068       return HAL_ERROR;
1069     }
1070
1071     return HAL_OK;
1072   }
1073   else
1074   {
1075     return HAL_BUSY;
1076   }
1077 }
1078
1079 /**
1080   * @brief  Writes block(s) to a specified address in a card. The Data transfer
1081   *         is managed in interrupt mode.
1082   * @note   This API should be followed by a check on the card state through
1083   *         HAL_SD_GetCardState().
1084   * @note   You could also check the IT transfer process through the SD Tx
1085   *         interrupt event.
1086   * @param  hsd: Pointer to SD handle
1087   * @param  pData: Pointer to the buffer that will contain the data to transmit
1088   * @param  BlockAdd: Block Address where data will be written
1089   * @param  NumberOfBlocks: Number of blocks to write
1090   * @retval HAL status
1091   */
1092 HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1093 {
1094   SDIO_DataInitTypeDef config;
1095   uint32_t errorstate;
1096   uint32_t add = BlockAdd;
1097
1098   if(NULL == pData)
1099   {
1100     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1101     return HAL_ERROR;
1102   }
1103
1104   if(hsd->State == HAL_SD_STATE_READY)
1105   {
1106     hsd->ErrorCode = HAL_SD_ERROR_NONE;
1107
1108     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1109     {
1110       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1111       return HAL_ERROR;
1112     }
1113
1114     hsd->State = HAL_SD_STATE_BUSY;
1115
1116     /* Initialize data control register */
1117     hsd->Instance->DCTRL = 0U;
1118
1119     hsd->pTxBuffPtr = pData;
1120     hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
1121
1122     /* Enable transfer interrupts */
1123 #if defined(SDIO_STA_STBITERR)
1124     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE | SDIO_IT_STBITERR));
1125 #else /* SDIO_STA_STBITERR not defined */
1126     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE));
1127 #endif /* SDIO_STA_STBITERR */
1128
1129     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1130     {
1131       add *= 512U;
1132     }
1133
1134     /* Set Block Size for Card */
1135     errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1136     if(errorstate != HAL_SD_ERROR_NONE)
1137     {
1138       /* Clear all the static flags */
1139       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1140       hsd->ErrorCode |= errorstate;
1141       hsd->State = HAL_SD_STATE_READY;
1142       return HAL_ERROR;
1143     }
1144
1145     /* Write Blocks in Polling mode */
1146     if(NumberOfBlocks > 1U)
1147     {
1148       hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);
1149
1150       /* Write Multi Block command */
1151       errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1152     }
1153     else
1154     {
1155       hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);
1156
1157       /* Write Single Block command */
1158       errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1159     }
1160     if(errorstate != HAL_SD_ERROR_NONE)
1161     {
1162       /* Clear all the static flags */
1163       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1164       hsd->ErrorCode |= errorstate;
1165       hsd->State = HAL_SD_STATE_READY;
1166       hsd->Context = SD_CONTEXT_NONE;
1167       return HAL_ERROR;
1168     }
1169
1170     /* Configure the SD DPSM (Data Path State Machine) */
1171     config.DataTimeOut   = SDMMC_DATATIMEOUT;
1172     config.DataLength    = BLOCKSIZE * NumberOfBlocks;
1173     config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1174     config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
1175     config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1176     config.DPSM          = SDIO_DPSM_ENABLE;
1177     (void)SDIO_ConfigData(hsd->Instance, &config);
1178
1179     return HAL_OK;
1180   }
1181   else
1182   {
1183     return HAL_BUSY;
1184   }
1185 }
1186
1187 /**
1188   * @brief  Reads block(s) from a specified address in a card. The Data transfer
1189   *         is managed by DMA mode.
1190   * @note   This API should be followed by a check on the card state through
1191   *         HAL_SD_GetCardState().
1192   * @note   You could also check the DMA transfer process through the SD Rx
1193   *         interrupt event.
1194   * @param  hsd: Pointer SD handle
1195   * @param  pData: Pointer to the buffer that will contain the received data
1196   * @param  BlockAdd: Block Address from where data is to be read
1197   * @param  NumberOfBlocks: Number of blocks to read.
1198   * @retval HAL status
1199   */
1200 HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1201 {
1202   SDIO_DataInitTypeDef config;
1203   uint32_t errorstate;
1204   uint32_t add = BlockAdd;
1205
1206   if(NULL == pData)
1207   {
1208     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1209     return HAL_ERROR;
1210   }
1211
1212   if(hsd->State == HAL_SD_STATE_READY)
1213   {
1214     hsd->ErrorCode = HAL_SD_ERROR_NONE;
1215
1216     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1217     {
1218       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1219       return HAL_ERROR;
1220     }
1221
1222     hsd->State = HAL_SD_STATE_BUSY;
1223
1224     /* Initialize data control register */
1225     hsd->Instance->DCTRL = 0U;
1226
1227 #if defined(SDIO_STA_STBITERR)
1228     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_IT_STBITERR));
1229 #else /* SDIO_STA_STBITERR not defined */
1230     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1231 #endif /* SDIO_STA_STBITERR */
1232
1233     /* Set the DMA transfer complete callback */
1234     hsd->hdmarx->XferCpltCallback = SD_DMAReceiveCplt;
1235
1236     /* Set the DMA error callback */
1237     hsd->hdmarx->XferErrorCallback = SD_DMAError;
1238
1239     /* Set the DMA Abort callback */
1240     hsd->hdmarx->XferAbortCallback = NULL;
1241
1242     /* Enable the DMA Channel */
1243     if(HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pData, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1244     {
1245       __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1246       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1247       hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1248       hsd->State = HAL_SD_STATE_READY;
1249       return HAL_ERROR;
1250     }
1251     else
1252     {
1253       /* Enable SD DMA transfer */
1254       // MM disabled, as this fails on fast cards. __HAL_SD_DMA_ENABLE(hsd);
1255
1256       if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1257       {
1258         add *= 512U;
1259
1260         /* Set Block Size for Card */
1261         errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1262         if(errorstate != HAL_SD_ERROR_NONE)
1263         {
1264           /* Clear all the static flags */
1265           __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1266           hsd->ErrorCode |= errorstate;
1267           hsd->State = HAL_SD_STATE_READY;
1268           return HAL_ERROR;
1269         }
1270       }
1271
1272       /* Configure the SD DPSM (Data Path State Machine) */
1273       config.DataTimeOut   = SDMMC_DATATIMEOUT;
1274       config.DataLength    = BLOCKSIZE * NumberOfBlocks;
1275       config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1276       config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
1277       config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1278       config.DPSM          = SDIO_DPSM_ENABLE;
1279
1280       // We cannot enable DMA too early on UHS-I class 3 SD cards, or else the
1281       // data is just discarded before the dpsm is started.
1282       __HAL_SD_DMA_ENABLE();
1283
1284       (void)SDIO_ConfigData(hsd->Instance, &config);
1285
1286       /* Read Blocks in DMA mode */
1287       if(NumberOfBlocks > 1U)
1288       {
1289         hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1290
1291         /* Read Multi Block command */
1292         errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1293       }
1294       else
1295       {
1296         hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
1297
1298         /* Read Single Block command */
1299         errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1300       }
1301       if(errorstate != HAL_SD_ERROR_NONE)
1302       {
1303         /* Clear all the static flags */
1304         __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1305         hsd->ErrorCode |= errorstate;
1306         hsd->State = HAL_SD_STATE_READY;
1307         hsd->Context = SD_CONTEXT_NONE;
1308         return HAL_ERROR;
1309       }
1310
1311       return HAL_OK;
1312     }
1313   }
1314   else
1315   {
1316     return HAL_BUSY;
1317   }
1318 }
1319
1320 /**
1321   * @brief  Writes block(s) to a specified address in a card. The Data transfer
1322   *         is managed by DMA mode.
1323   * @note   This API should be followed by a check on the card state through
1324   *         HAL_SD_GetCardState().
1325   * @note   You could also check the DMA transfer process through the SD Tx
1326   *         interrupt event.
1327   * @param  hsd: Pointer to SD handle
1328   * @param  pData: Pointer to the buffer that will contain the data to transmit
1329   * @param  BlockAdd: Block Address where data will be written
1330   * @param  NumberOfBlocks: Number of blocks to write
1331   * @retval HAL status
1332   */
1333 HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1334 {
1335   SDIO_DataInitTypeDef config;
1336   uint32_t errorstate;
1337   uint32_t add = BlockAdd;
1338
1339   if(NULL == pData)
1340   {
1341     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1342     return HAL_ERROR;
1343   }
1344
1345   if(hsd->State == HAL_SD_STATE_READY)
1346   {
1347     hsd->ErrorCode = HAL_SD_ERROR_NONE;
1348
1349     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1350     {
1351       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1352       return HAL_ERROR;
1353     }
1354
1355     hsd->State = HAL_SD_STATE_BUSY;
1356
1357     /* Initialize data control register */
1358     hsd->Instance->DCTRL = 0U;
1359
1360     /* Enable SD Error interrupts */
1361 #if defined(SDIO_STA_STBITERR)
1362     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR));
1363 #else /* SDIO_STA_STBITERR not defined */
1364     __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));   
1365 #endif /* SDIO_STA_STBITERR */
1366
1367     /* Set the DMA transfer complete callback */
1368     hsd->hdmatx->XferCpltCallback = SD_DMATransmitCplt;
1369
1370     /* Set the DMA error callback */
1371     hsd->hdmatx->XferErrorCallback = SD_DMAError;
1372
1373     /* Set the DMA Abort callback */
1374     hsd->hdmatx->XferAbortCallback = NULL;
1375
1376     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1377     {
1378       add *= 512U;
1379
1380       /* Set Block Size for Card */
1381       errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1382       if(errorstate != HAL_SD_ERROR_NONE)
1383       {
1384         /* Clear all the static flags */
1385         __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1386         hsd->ErrorCode |= errorstate;
1387         hsd->State = HAL_SD_STATE_READY;
1388         return HAL_ERROR;
1389       }
1390     }
1391
1392     /* Write Blocks in Polling mode */
1393     if(NumberOfBlocks > 1U)
1394     {
1395       hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1396
1397       /* MM: Prepare for write */
1398 /* TODO
1399       SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->RCA << 16));
1400       SDIO_CmdInitTypeDef  mm_cmdinit;
1401       mm_cmdinit.Argument         = (uint32_t)NumberOfBlocks;
1402       mm_cmdinit.CmdIndex         = SDMMC_CMD_SET_BLOCK_COUNT;
1403       mm_cmdinit.Response         = SDIO_RESPONSE_SHORT;
1404       mm_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
1405       mm_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
1406       (void)SDIO_SendCommand(hsd->Instance, &mm_cmdinit);
1407       SDMMC_GetCmdResp1(hsd->Instance, SDMMC_CMD_SET_BLOCK_COUNT, SDIO_CMDTIMEOUT);*/
1408
1409       /* Write Multi Block command */
1410       errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1411     }
1412     else
1413     {
1414       hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
1415
1416       /* Write Single Block command */
1417       errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1418     }
1419     if(errorstate != HAL_SD_ERROR_NONE)
1420     {
1421       /* Clear all the static flags */
1422       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1423       hsd->ErrorCode |= errorstate;
1424       hsd->State = HAL_SD_STATE_READY;
1425       hsd->Context = SD_CONTEXT_NONE;
1426       return HAL_ERROR;
1427     }
1428
1429     /* Enable SDIO DMA transfer */
1430     // MM disabled, as this fails on fast cards. __HAL_SD_DMA_ENABLE(hsd);
1431
1432     /* Enable the DMA Channel */
1433     if(HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pData, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1434     {
1435 #if defined(SDIO_STA_STBITERR)
1436       __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR));
1437 #else /* SDIO_STA_STBITERR not defined */
1438       __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));   
1439 #endif /* SDIO_STA_STBITERR */
1440       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1441       hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1442       hsd->State = HAL_SD_STATE_READY;
1443       hsd->Context = SD_CONTEXT_NONE;
1444       return HAL_ERROR;
1445     }
1446     else
1447     {
1448       /* Configure the SD DPSM (Data Path State Machine) */
1449       config.DataTimeOut   = SDMMC_DATATIMEOUT;
1450       config.DataLength    = BLOCKSIZE * NumberOfBlocks;
1451       config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1452       config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
1453       config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1454       config.DPSM          = SDIO_DPSM_ENABLE;
1455
1456       // We cannot enable DMA too early on UHS-I class 3 SD cards, or else the
1457       // data is just discarded before the dpsm is started.
1458       __HAL_SD_DMA_ENABLE();
1459
1460       (void)SDIO_ConfigData(hsd->Instance, &config);
1461
1462       return HAL_OK;
1463     }
1464   }
1465   else
1466   {
1467     return HAL_BUSY;
1468   }
1469 }
1470
1471 /**
1472   * @brief  Erases the specified memory area of the given SD card.
1473   * @note   This API should be followed by a check on the card state through
1474   *         HAL_SD_GetCardState().
1475   * @param  hsd: Pointer to SD handle
1476   * @param  BlockStartAdd: Start Block address
1477   * @param  BlockEndAdd: End Block address
1478   * @retval HAL status
1479   */
1480 HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
1481 {
1482   uint32_t errorstate;
1483   uint32_t start_add = BlockStartAdd;
1484   uint32_t end_add = BlockEndAdd;
1485
1486   if(hsd->State == HAL_SD_STATE_READY)
1487   {
1488     hsd->ErrorCode = HAL_SD_ERROR_NONE;
1489
1490     if(end_add < start_add)
1491     {
1492       hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1493       return HAL_ERROR;
1494     }
1495
1496     if(end_add > (hsd->SdCard.LogBlockNbr))
1497     {
1498       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1499       return HAL_ERROR;
1500     }
1501
1502     hsd->State = HAL_SD_STATE_BUSY;
1503
1504     /* Check if the card command class supports erase command */
1505     if(((hsd->SdCard.Class) & SDIO_CCCC_ERASE) == 0U)
1506     {
1507       /* Clear all the static flags */
1508       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1509       hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
1510       hsd->State = HAL_SD_STATE_READY;
1511       return HAL_ERROR;
1512     }
1513
1514     if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
1515     {
1516       /* Clear all the static flags */
1517       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1518       hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
1519       hsd->State = HAL_SD_STATE_READY;
1520       return HAL_ERROR;
1521     }
1522
1523     /* Get start and end block for high capacity cards */
1524     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1525     {
1526       start_add *= 512U;
1527       end_add   *= 512U;
1528     }
1529
1530     /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1531     if(hsd->SdCard.CardType != CARD_SECURED)
1532     {
1533       /* Send CMD32 SD_ERASE_GRP_START with argument as addr  */
1534       errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
1535       if(errorstate != HAL_SD_ERROR_NONE)
1536       {
1537         /* Clear all the static flags */
1538         __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1539         hsd->ErrorCode |= errorstate;
1540         hsd->State = HAL_SD_STATE_READY;
1541         return HAL_ERROR;
1542       }
1543
1544       /* Send CMD33 SD_ERASE_GRP_END with argument as addr  */
1545       errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
1546       if(errorstate != HAL_SD_ERROR_NONE)
1547       {
1548         /* Clear all the static flags */
1549         __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1550         hsd->ErrorCode |= errorstate;
1551         hsd->State = HAL_SD_STATE_READY;
1552         return HAL_ERROR;
1553       }
1554     }
1555
1556     /* Send CMD38 ERASE */
1557     errorstate = SDMMC_CmdErase(hsd->Instance);
1558     if(errorstate != HAL_SD_ERROR_NONE)
1559     {
1560       /* Clear all the static flags */
1561       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1562       hsd->ErrorCode |= errorstate;
1563       hsd->State = HAL_SD_STATE_READY;
1564       return HAL_ERROR;
1565     }
1566
1567     hsd->State = HAL_SD_STATE_READY;
1568
1569     return HAL_OK;
1570   }
1571   else
1572   {
1573     return HAL_BUSY;
1574   }
1575 }
1576
1577 /**
1578   * @brief  This function handles SD card interrupt request.
1579   * @param  hsd: Pointer to SD handle
1580   * @retval None
1581   */
1582 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1583 {
1584   uint32_t errorstate;
1585   uint32_t context = hsd->Context;
1586
1587   /* Check for SDIO interrupt flags */
1588   if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1589   {
1590     SD_Read_IT(hsd);
1591   }
1592
1593   else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) != RESET)
1594   {
1595     __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DATAEND);
1596
1597 #if defined(SDIO_STA_STBITERR)
1598     __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND  | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1599                              SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR  | SDIO_IT_TXFIFOHE |\
1600                              SDIO_IT_RXFIFOHF | SDIO_IT_STBITERR);
1601 #else /* SDIO_STA_STBITERR not defined */
1602     __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND  | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1603                              SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR  | SDIO_IT_TXFIFOHE |\
1604                              SDIO_IT_RXFIFOHF);
1605 #endif /* SDIO_STA_STBITERR */
1606
1607     hsd->Instance->DCTRL &= ~(SDIO_DCTRL_DTEN);
1608     
1609     if((context & SD_CONTEXT_IT) != 0U)
1610     {
1611       if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1612       {
1613         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1614         if(errorstate != HAL_SD_ERROR_NONE)
1615         {
1616           hsd->ErrorCode |= errorstate;
1617 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1618           hsd->ErrorCallback(hsd);
1619 #else
1620           HAL_SD_ErrorCallback(hsd);
1621 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1622         }
1623       }
1624
1625       /* Clear all the static flags */
1626       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
1627
1628       hsd->State = HAL_SD_STATE_READY;
1629       hsd->Context = SD_CONTEXT_NONE;
1630       if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1631       {
1632 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1633         hsd->RxCpltCallback(hsd);
1634 #else
1635         HAL_SD_RxCpltCallback(hsd);
1636 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1637       }
1638       else
1639       {
1640 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1641         hsd->TxCpltCallback(hsd);
1642 #else
1643         HAL_SD_TxCpltCallback(hsd);
1644 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1645       }
1646     }
1647     else if((context & SD_CONTEXT_DMA) != 0U)
1648     {
1649       if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1650       {
1651         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1652         if(errorstate != HAL_SD_ERROR_NONE)
1653         {
1654           hsd->ErrorCode |= errorstate;
1655 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1656           hsd->ErrorCallback(hsd);
1657 #else
1658           HAL_SD_ErrorCallback(hsd);
1659 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1660         }
1661       }
1662       if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) == 0U) && ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) == 0U))
1663       {
1664         /* Disable the DMA transfer for transmit request by setting the DMAEN bit
1665         in the SD DCTRL register */
1666         hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
1667
1668         hsd->State = HAL_SD_STATE_READY;
1669
1670 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1671         hsd->TxCpltCallback(hsd);
1672 #else
1673         HAL_SD_TxCpltCallback(hsd);
1674 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1675       }
1676     }
1677     else
1678     {
1679       /* Nothing to do */
1680     }
1681   }
1682
1683   else if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1684   {
1685     SD_Write_IT(hsd);
1686   }
1687
1688 #if defined(SDIO_STA_STBITERR)
1689   else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR | SDIO_FLAG_STBITERR) != RESET)
1690 #else /* SDIO_STA_STBITERR not defined */
1691   else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR) != RESET)
1692 #endif /* SDIO_STA_STBITERR */
1693   {
1694     /* Set Error code */
1695     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL) != RESET)
1696     {
1697       hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
1698     }
1699     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) != RESET)
1700     {
1701       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1702     }
1703     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR) != RESET)
1704     {
1705       hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
1706     }
1707     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR) != RESET)
1708     {
1709       hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
1710     }
1711 #if defined(SDIO_STA_STBITERR)
1712     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR) != RESET)
1713     {
1714       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1715     }
1716 #endif /* SDIO_STA_STBITERR */
1717
1718 #if defined(SDIO_STA_STBITERR)
1719     /* Clear All flags */
1720     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS | SDIO_FLAG_STBITERR);
1721
1722     /* Disable all interrupts */
1723     __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1724                              SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1725 #else /* SDIO_STA_STBITERR not defined */
1726     /* Clear All flags */
1727     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
1728
1729     /* Disable all interrupts */
1730     __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1731                              SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
1732 #endif /* SDIO_STA_STBITERR */
1733
1734     hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
1735
1736     if((context & SD_CONTEXT_IT) != 0U)
1737     {
1738       /* Set the SD state to ready to be able to start again the process */
1739       hsd->State = HAL_SD_STATE_READY;
1740       hsd->Context = SD_CONTEXT_NONE;
1741 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1742       hsd->ErrorCallback(hsd);
1743 #else
1744       HAL_SD_ErrorCallback(hsd);
1745 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1746     }
1747     else if((context & SD_CONTEXT_DMA) != 0U)
1748     {
1749       /* Abort the SD DMA channel */
1750       if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1751       {
1752         /* Set the DMA Tx abort callback */
1753         hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
1754         /* Abort DMA in IT mode */
1755         if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
1756         {
1757           SD_DMATxAbort(hsd->hdmatx);
1758         }
1759       }
1760       else if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1761       {
1762         /* Set the DMA Rx abort callback */
1763         hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
1764         /* Abort DMA in IT mode */
1765         if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
1766         {
1767           SD_DMARxAbort(hsd->hdmarx);
1768         }
1769       }
1770       else
1771       {
1772         hsd->ErrorCode = HAL_SD_ERROR_NONE;
1773         hsd->State = HAL_SD_STATE_READY;
1774         hsd->Context = SD_CONTEXT_NONE;
1775 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1776         hsd->AbortCpltCallback(hsd);
1777 #else
1778         HAL_SD_AbortCallback(hsd);
1779 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1780       }
1781     }
1782     else
1783     {
1784       /* Nothing to do */
1785     }
1786   }
1787   else
1788   {
1789     /* Nothing to do */
1790   }
1791 }
1792
1793 /**
1794   * @brief return the SD state
1795   * @param hsd: Pointer to sd handle
1796   * @retval HAL state
1797   */
1798 HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
1799 {
1800   return hsd->State;
1801 }
1802
1803 /**
1804 * @brief  Return the SD error code
1805 * @param  hsd : Pointer to a SD_HandleTypeDef structure that contains
1806   *              the configuration information.
1807 * @retval SD Error Code
1808 */
1809 uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
1810 {
1811   return hsd->ErrorCode;
1812 }
1813
1814 /**
1815   * @brief Tx Transfer completed callbacks
1816   * @param hsd: Pointer to SD handle
1817   * @retval None
1818   */
1819 __weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
1820 {
1821   /* Prevent unused argument(s) compilation warning */
1822   UNUSED(hsd);
1823
1824   /* NOTE : This function should not be modified, when the callback is needed,
1825             the HAL_SD_TxCpltCallback can be implemented in the user file
1826    */
1827 }
1828
1829 /**
1830   * @brief Rx Transfer completed callbacks
1831   * @param hsd: Pointer SD handle
1832   * @retval None
1833   */
1834 __weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
1835 {
1836   /* Prevent unused argument(s) compilation warning */
1837   UNUSED(hsd);
1838
1839   /* NOTE : This function should not be modified, when the callback is needed,
1840             the HAL_SD_RxCpltCallback can be implemented in the user file
1841    */
1842 }
1843
1844 /**
1845   * @brief SD error callbacks
1846   * @param hsd: Pointer SD handle
1847   * @retval None
1848   */
1849 __weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
1850 {
1851   /* Prevent unused argument(s) compilation warning */
1852   UNUSED(hsd);
1853
1854   /* NOTE : This function should not be modified, when the callback is needed,
1855             the HAL_SD_ErrorCallback can be implemented in the user file
1856    */
1857 }
1858
1859 /**
1860   * @brief SD Abort callbacks
1861   * @param hsd: Pointer SD handle
1862   * @retval None
1863   */
1864 __weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
1865 {
1866   /* Prevent unused argument(s) compilation warning */
1867   UNUSED(hsd);
1868
1869   /* NOTE : This function should not be modified, when the callback is needed,
1870             the HAL_SD_AbortCallback can be implemented in the user file
1871    */
1872 }
1873
1874 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1875 /**
1876   * @brief  Register a User SD Callback
1877   *         To be used instead of the weak (surcharged) predefined callback
1878   * @param hsd : SD handle
1879   * @param CallbackID : ID of the callback to be registered
1880   *        This parameter can be one of the following values:
1881   *          @arg @ref HAL_SD_TX_CPLT_CB_ID    SD Tx Complete Callback ID
1882   *          @arg @ref HAL_SD_RX_CPLT_CB_ID    SD Rx Complete Callback ID
1883   *          @arg @ref HAL_SD_ERROR_CB_ID      SD Error Callback ID
1884   *          @arg @ref HAL_SD_ABORT_CB_ID      SD Abort Callback ID
1885   *          @arg @ref HAL_SD_MSP_INIT_CB_ID   SD MspInit Callback ID
1886   *          @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
1887   * @param pCallback : pointer to the Callback function
1888   * @retval status
1889   */
1890 HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
1891 {
1892   HAL_StatusTypeDef status = HAL_OK;
1893
1894   if(pCallback == NULL)
1895   {
1896     /* Update the error code */
1897     hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1898     return HAL_ERROR;
1899   }
1900
1901   /* Process locked */
1902   __HAL_LOCK(hsd);
1903
1904   if(hsd->State == HAL_SD_STATE_READY)
1905   {
1906     switch (CallbackID)
1907     {
1908     case HAL_SD_TX_CPLT_CB_ID :
1909       hsd->TxCpltCallback = pCallback;
1910       break;
1911     case HAL_SD_RX_CPLT_CB_ID :
1912       hsd->RxCpltCallback = pCallback;
1913       break;
1914     case HAL_SD_ERROR_CB_ID :
1915       hsd->ErrorCallback = pCallback;
1916       break;
1917     case HAL_SD_ABORT_CB_ID :
1918       hsd->AbortCpltCallback = pCallback;
1919       break;
1920     case HAL_SD_MSP_INIT_CB_ID :
1921       hsd->MspInitCallback = pCallback;
1922       break;
1923     case HAL_SD_MSP_DEINIT_CB_ID :
1924       hsd->MspDeInitCallback = pCallback;
1925       break;
1926     default :
1927       /* Update the error code */
1928       hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1929       /* update return status */
1930       status =  HAL_ERROR;
1931       break;
1932     }
1933   }
1934   else if (hsd->State == HAL_SD_STATE_RESET)
1935   {
1936     switch (CallbackID)
1937     {
1938     case HAL_SD_MSP_INIT_CB_ID :
1939       hsd->MspInitCallback = pCallback;
1940       break;
1941     case HAL_SD_MSP_DEINIT_CB_ID :
1942       hsd->MspDeInitCallback = pCallback;
1943       break;
1944     default :
1945       /* Update the error code */
1946       hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1947       /* update return status */
1948       status =  HAL_ERROR;
1949       break;
1950     }
1951   }
1952   else
1953   {
1954     /* Update the error code */
1955     hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1956     /* update return status */
1957     status =  HAL_ERROR;
1958   }
1959
1960   /* Release Lock */
1961   __HAL_UNLOCK(hsd);
1962   return status;
1963 }
1964
1965 /**
1966   * @brief  Unregister a User SD Callback
1967   *         SD Callback is redirected to the weak (surcharged) predefined callback
1968   * @param hsd : SD handle
1969   * @param CallbackID : ID of the callback to be unregistered
1970   *        This parameter can be one of the following values:
1971   *          @arg @ref HAL_SD_TX_CPLT_CB_ID    SD Tx Complete Callback ID
1972   *          @arg @ref HAL_SD_RX_CPLT_CB_ID    SD Rx Complete Callback ID
1973   *          @arg @ref HAL_SD_ERROR_CB_ID      SD Error Callback ID
1974   *          @arg @ref HAL_SD_ABORT_CB_ID      SD Abort Callback ID
1975   *          @arg @ref HAL_SD_MSP_INIT_CB_ID   SD MspInit Callback ID
1976   *          @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
1977   * @retval status
1978   */
1979 HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
1980 {
1981   HAL_StatusTypeDef status = HAL_OK;
1982
1983   /* Process locked */
1984   __HAL_LOCK(hsd);
1985
1986   if(hsd->State == HAL_SD_STATE_READY)
1987   {
1988     switch (CallbackID)
1989     {
1990     case HAL_SD_TX_CPLT_CB_ID :
1991       hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
1992       break;
1993     case HAL_SD_RX_CPLT_CB_ID :
1994       hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
1995       break;
1996     case HAL_SD_ERROR_CB_ID :
1997       hsd->ErrorCallback = HAL_SD_ErrorCallback;
1998       break;
1999     case HAL_SD_ABORT_CB_ID :
2000       hsd->AbortCpltCallback = HAL_SD_AbortCallback;
2001       break;
2002     case HAL_SD_MSP_INIT_CB_ID :
2003       hsd->MspInitCallback = HAL_SD_MspInit;
2004       break;
2005     case HAL_SD_MSP_DEINIT_CB_ID :
2006       hsd->MspDeInitCallback = HAL_SD_MspDeInit;
2007       break;
2008     default :
2009       /* Update the error code */
2010       hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2011       /* update return status */
2012       status =  HAL_ERROR;
2013       break;
2014     }
2015   }
2016   else if (hsd->State == HAL_SD_STATE_RESET)
2017   {
2018     switch (CallbackID)
2019     {
2020     case HAL_SD_MSP_INIT_CB_ID :
2021       hsd->MspInitCallback = HAL_SD_MspInit;
2022       break;
2023     case HAL_SD_MSP_DEINIT_CB_ID :
2024       hsd->MspDeInitCallback = HAL_SD_MspDeInit;
2025       break;
2026     default :
2027       /* Update the error code */
2028       hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2029       /* update return status */
2030       status =  HAL_ERROR;
2031       break;
2032     }
2033   }
2034   else
2035   {
2036     /* Update the error code */
2037     hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2038     /* update return status */
2039     status =  HAL_ERROR;
2040   }
2041
2042   /* Release Lock */
2043   __HAL_UNLOCK(hsd);
2044   return status;
2045 }
2046 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2047
2048 /**
2049   * @}
2050   */
2051
2052 /** @addtogroup SD_Exported_Functions_Group3
2053  *  @brief   management functions
2054  *
2055 @verbatim
2056   ==============================================================================
2057                       ##### Peripheral Control functions #####
2058   ==============================================================================
2059   [..]
2060     This subsection provides a set of functions allowing to control the SD card
2061     operations and get the related information
2062
2063 @endverbatim
2064   * @{
2065   */
2066
2067 /**
2068   * @brief  Returns information the information of the card which are stored on
2069   *         the CID register.
2070   * @param  hsd: Pointer to SD handle
2071   * @param  pCID: Pointer to a HAL_SD_CardCIDTypeDef structure that  
2072   *         contains all CID register parameters
2073   * @retval HAL status
2074   */
2075 HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
2076 {
2077   pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U);
2078
2079   pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U);
2080
2081   pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U));
2082
2083   pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU);
2084
2085   pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U);
2086
2087   pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U));
2088
2089   pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U);
2090
2091   pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U);
2092
2093   pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U);
2094
2095   pCID->Reserved2 = 1U;
2096
2097   return HAL_OK;
2098 }
2099
2100 /**
2101   * @brief  Returns information the information of the card which are stored on
2102   *         the CSD register.
2103   * @param  hsd: Pointer to SD handle
2104   * @param  pCSD: Pointer to a HAL_SD_CardCSDTypeDef structure that  
2105   *         contains all CSD register parameters
2106   * @retval HAL status
2107   */
2108 HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
2109 {
2110   pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U);
2111
2112   pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U);
2113
2114   pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U);
2115
2116   pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U);
2117
2118   pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U);
2119
2120   pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU);
2121
2122   pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U);
2123
2124   pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U);
2125
2126   pCSD->PartBlockRead   = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U);
2127
2128   pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U);
2129
2130   pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U);
2131
2132   pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U);
2133
2134   pCSD->Reserved2 = 0U; /*!< Reserved */
2135
2136   if(hsd->SdCard.CardType == CARD_SDSC)
2137   {
2138     pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U));
2139
2140     pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U);
2141
2142     pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U);
2143
2144     pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U);
2145
2146     pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U);
2147
2148     pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U);
2149
2150     hsd->SdCard.BlockNbr  = (pCSD->DeviceSize + 1U) ;
2151     hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
2152     hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
2153
2154     hsd->SdCard.LogBlockNbr =  (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U);
2155     hsd->SdCard.LogBlockSize = 512U;
2156   }
2157   else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)
2158   {
2159     /* Byte 7 */
2160     pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U));
2161
2162     hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U);
2163     hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr;
2164     hsd->SdCard.BlockSize = 512U;
2165     hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize;
2166   }
2167   else
2168   {
2169     /* Clear all the static flags */
2170     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2171     hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2172     hsd->State = HAL_SD_STATE_READY;
2173     return HAL_ERROR;
2174   }
2175
2176   pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U);
2177
2178   pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U);
2179
2180   pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU);
2181
2182   pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U);
2183
2184   pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U);
2185
2186   pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U);
2187
2188   pCSD->MaxWrBlockLen= (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U);
2189
2190   pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U);
2191
2192   pCSD->Reserved3 = 0;
2193
2194   pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U);
2195
2196   pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U);
2197
2198   pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U);
2199
2200   pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U);
2201
2202   pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U);
2203
2204   pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U);
2205
2206   pCSD->ECC= (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U);
2207
2208   pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U);
2209
2210   pCSD->Reserved4 = 1;
2211
2212   return HAL_OK;
2213 }
2214
2215 /**
2216   * @brief  Gets the SD status info.
2217   * @param  hsd: Pointer to SD handle
2218   * @param  pStatus: Pointer to the HAL_SD_CardStatusTypeDef structure that 
2219   *         will contain the SD card status information
2220   * @retval HAL status
2221   */
2222 HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
2223 {
2224   uint32_t sd_status[16];
2225   uint32_t errorstate;
2226
2227   errorstate = SD_SendSDStatus(hsd, sd_status);
2228   if(errorstate != HAL_SD_ERROR_NONE)
2229   {
2230     /* Clear all the static flags */
2231     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2232     hsd->ErrorCode |= errorstate;
2233     hsd->State = HAL_SD_STATE_READY;
2234     return HAL_ERROR;
2235   }
2236   else
2237   {
2238     pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U);
2239
2240     pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U);
2241
2242     pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U));
2243
2244     pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U)    | ((sd_status[1] & 0xFF00U) << 8U) |
2245                                   ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U));
2246
2247     pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU);
2248
2249     pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U);
2250
2251     pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U);
2252
2253     pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU));
2254
2255     pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U);
2256
2257     pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U);
2258   }
2259
2260   return HAL_OK;
2261 }
2262
2263 /**
2264   * @brief  Gets the SD card info.
2265   * @param  hsd: Pointer to SD handle
2266   * @param  pCardInfo: Pointer to the HAL_SD_CardInfoTypeDef structure that
2267   *         will contain the SD card status information
2268   * @retval HAL status
2269   */
2270 HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
2271 {
2272   pCardInfo->CardType     = (uint32_t)(hsd->SdCard.CardType);
2273   pCardInfo->CardVersion  = (uint32_t)(hsd->SdCard.CardVersion);
2274   pCardInfo->Class        = (uint32_t)(hsd->SdCard.Class);
2275   pCardInfo->RelCardAdd   = (uint32_t)(hsd->SdCard.RelCardAdd);
2276   pCardInfo->BlockNbr     = (uint32_t)(hsd->SdCard.BlockNbr);
2277   pCardInfo->BlockSize    = (uint32_t)(hsd->SdCard.BlockSize);
2278   pCardInfo->LogBlockNbr  = (uint32_t)(hsd->SdCard.LogBlockNbr);
2279   pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);
2280
2281   return HAL_OK;
2282 }
2283
2284 /**
2285   * @brief  Enables wide bus operation for the requested card if supported by
2286   *         card.
2287   * @param  hsd: Pointer to SD handle
2288   * @param  WideMode: Specifies the SD card wide bus mode
2289   *          This parameter can be one of the following values:
2290   *            @arg SDIO_BUS_WIDE_8B: 8-bit data transfer
2291   *            @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
2292   *            @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
2293   * @retval HAL status
2294   */
2295 HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
2296 {
2297   SDIO_InitTypeDef Init;
2298   uint32_t errorstate;
2299
2300   /* Check the parameters */
2301   assert_param(IS_SDIO_BUS_WIDE(WideMode));
2302
2303   /* Change State */
2304   hsd->State = HAL_SD_STATE_BUSY;
2305
2306   if(hsd->SdCard.CardType != CARD_SECURED)
2307   {
2308     if(WideMode == SDIO_BUS_WIDE_8B)
2309     {
2310       hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2311     }
2312     else if(WideMode == SDIO_BUS_WIDE_4B)
2313     {
2314       errorstate = SD_WideBus_Enable(hsd);
2315
2316       hsd->ErrorCode |= errorstate;
2317     }
2318     else if(WideMode == SDIO_BUS_WIDE_1B)
2319     {
2320       errorstate = SD_WideBus_Disable(hsd);
2321
2322       hsd->ErrorCode |= errorstate;
2323     }
2324     else
2325     {
2326       /* WideMode is not a valid argument*/
2327       hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2328     }
2329   }
2330   else
2331   {
2332     /* MMC Card does not support this feature */
2333     hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2334   }
2335
2336   if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2337   {
2338     /* Clear all the static flags */
2339     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2340     hsd->State = HAL_SD_STATE_READY;
2341     return HAL_ERROR;
2342   }
2343   else
2344   {
2345     /* Configure the SDIO peripheral */
2346     Init.ClockEdge           = hsd->Init.ClockEdge;
2347     Init.ClockBypass         = hsd->Init.ClockBypass;
2348     Init.ClockPowerSave      = hsd->Init.ClockPowerSave;
2349     Init.BusWide             = WideMode;
2350     Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;
2351     Init.ClockDiv            = hsd->Init.ClockDiv;
2352     (void)SDIO_Init(hsd->Instance, Init);
2353   }
2354
2355   /* Change State */
2356   hsd->State = HAL_SD_STATE_READY;
2357
2358   return HAL_OK;
2359 }
2360
2361 /**
2362   * @brief  Gets the current sd card data state.
2363   * @param  hsd: pointer to SD handle
2364   * @retval Card state
2365   */
2366 HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
2367 {
2368   uint32_t cardstate;
2369   uint32_t errorstate;
2370   uint32_t resp1 = 0;
2371
2372   errorstate = SD_SendStatus(hsd, &resp1);
2373   if(errorstate != HAL_SD_ERROR_NONE)
2374   {
2375     hsd->ErrorCode |= errorstate;
2376   }
2377
2378   cardstate = ((resp1 >> 9U) & 0x0FU);
2379
2380   return (HAL_SD_CardStateTypeDef)cardstate;
2381 }
2382
2383 /**
2384   * @brief  Abort the current transfer and disable the SD.
2385   * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
2386   *                the configuration information for SD module.
2387   * @retval HAL status
2388   */
2389 HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
2390 {
2391   HAL_SD_CardStateTypeDef CardState;
2392   uint32_t context = hsd->Context;
2393
2394   /* DIsable All interrupts */
2395   __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2396                            SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2397
2398   /* Clear All flags */
2399   __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2400
2401   CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
2402
2403   if ((context & SD_CONTEXT_DMA) != 0U)
2404   {
2405     /* Disable the SD DMA request */
2406     hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2407
2408     /* Abort the SD DMA Tx channel */
2409     if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
2410     {
2411       if(HAL_DMA_Abort(hsd->hdmatx) != HAL_OK)
2412       {
2413         hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2414       }
2415     }
2416     /* Abort the SD DMA Rx channel */
2417     else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
2418     {
2419       if(HAL_DMA_Abort(hsd->hdmarx) != HAL_OK)
2420       {
2421         hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2422       }
2423     }
2424     else
2425     {
2426       /* Nothing to do */
2427     }
2428   }
2429
2430   hsd->State = HAL_SD_STATE_READY;
2431
2432   /* Initialize the SD operation */
2433   hsd->Context = SD_CONTEXT_NONE;
2434
2435   CardState = HAL_SD_GetCardState(hsd);
2436   if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2437   {
2438     hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2439   }
2440   if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2441   {
2442     return HAL_ERROR;
2443   }
2444   return HAL_OK;
2445 }
2446
2447 /**
2448   * @brief  Abort the current transfer and disable the SD (IT mode).
2449   * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
2450   *                the configuration information for SD module.
2451   * @retval HAL status
2452   */
2453 HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
2454 {
2455   HAL_SD_CardStateTypeDef CardState;
2456   uint32_t context = hsd->Context;
2457
2458   /* Disable All interrupts */
2459   __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2460                            SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2461
2462   CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
2463
2464   if ((context & SD_CONTEXT_DMA) != 0U)
2465   {
2466     /* Disable the SD DMA request */
2467     hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2468
2469     /* Abort the SD DMA Tx channel */
2470     if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
2471     {
2472       hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
2473       if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
2474       {
2475         hsd->hdmatx = NULL;
2476       }
2477     }
2478     /* Abort the SD DMA Rx channel */
2479     else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
2480     {
2481       hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
2482       if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
2483       {
2484         hsd->hdmarx = NULL;
2485       }
2486     }
2487     else
2488     {
2489       /* Nothing to do */
2490     }
2491   }
2492   /* No transfer ongoing on both DMA channels*/
2493   else
2494   {
2495     /* Clear All flags */
2496     __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2497
2498     CardState = HAL_SD_GetCardState(hsd);
2499     hsd->State = HAL_SD_STATE_READY;
2500     hsd->Context = SD_CONTEXT_NONE;
2501     if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2502     {
2503       hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2504     }
2505     if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2506     {
2507       return HAL_ERROR;
2508     }
2509     else
2510     {
2511 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2512       hsd->AbortCpltCallback(hsd);
2513 #else
2514       HAL_SD_AbortCallback(hsd);
2515 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2516     }
2517   }
2518
2519   return HAL_OK;
2520 }
2521
2522 /**
2523   * @}
2524   */
2525
2526 /**
2527   * @}
2528   */
2529
2530 /* Private function ----------------------------------------------------------*/
2531 /** @addtogroup SD_Private_Functions
2532   * @{
2533   */
2534
2535 /**
2536   * @brief  DMA SD transmit process complete callback
2537   * @param  hdma: DMA handle
2538   * @retval None
2539   */
2540 static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
2541 {
2542   SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2543
2544   /* Enable DATAEND Interrupt */
2545   __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DATAEND));
2546 }
2547
2548 /**
2549   * @brief  DMA SD receive process complete callback
2550   * @param  hdma: DMA handle
2551   * @retval None
2552   */
2553 static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
2554 {
2555   SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2556   uint32_t errorstate;
2557
2558   /* Send stop command in multiblock write */
2559   if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))
2560   {
2561     errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
2562     if(errorstate != HAL_SD_ERROR_NONE)
2563     {
2564       hsd->ErrorCode |= errorstate;
2565 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2566       hsd->ErrorCallback(hsd);
2567 #else
2568       HAL_SD_ErrorCallback(hsd);
2569 #endif
2570     }
2571   }
2572
2573   /* Disable the DMA transfer for transmit request by setting the DMAEN bit
2574   in the SD DCTRL register */
2575   hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2576
2577   /* Clear all the static flags */
2578   __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2579
2580   hsd->State = HAL_SD_STATE_READY;
2581   hsd->Context = SD_CONTEXT_NONE;
2582
2583 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2584   hsd->RxCpltCallback(hsd);
2585 #else
2586   HAL_SD_RxCpltCallback(hsd);
2587 #endif
2588 }
2589
2590 /**
2591   * @brief  DMA SD communication error callback
2592   * @param  hdma: DMA handle
2593   * @retval None
2594   */
2595 static void SD_DMAError(DMA_HandleTypeDef *hdma)
2596 {
2597   SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2598   HAL_SD_CardStateTypeDef CardState;
2599   uint32_t RxErrorCode, TxErrorCode;
2600
2601   /* if DMA error is FIFO error ignore it */
2602   if(HAL_DMA_GetError(hdma) != HAL_DMA_ERROR_FE)
2603   {
2604     RxErrorCode = hsd->hdmarx->ErrorCode;
2605     TxErrorCode = hsd->hdmatx->ErrorCode;  
2606     if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
2607     {
2608       /* Clear All flags */
2609       __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2610
2611       /* Disable All interrupts */
2612       __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2613         SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2614
2615       hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2616       CardState = HAL_SD_GetCardState(hsd);
2617       if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2618       {
2619         hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2620       }
2621
2622       hsd->State= HAL_SD_STATE_READY;
2623       hsd->Context = SD_CONTEXT_NONE;
2624     }
2625
2626 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2627     hsd->ErrorCallback(hsd);
2628 #else
2629     HAL_SD_ErrorCallback(hsd);
2630 #endif
2631   }
2632 }
2633
2634 /**
2635   * @brief  DMA SD Tx Abort callback
2636   * @param  hdma: DMA handle
2637   * @retval None
2638   */
2639 static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
2640 {
2641   SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2642   HAL_SD_CardStateTypeDef CardState;
2643
2644   /* Clear All flags */
2645   __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2646
2647   CardState = HAL_SD_GetCardState(hsd);
2648   hsd->State = HAL_SD_STATE_READY;
2649   hsd->Context = SD_CONTEXT_NONE;
2650   if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2651   {
2652     hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2653   }
2654
2655   if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
2656   {
2657 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2658     hsd->AbortCpltCallback(hsd);
2659 #else
2660     HAL_SD_AbortCallback(hsd);
2661 #endif
2662   }
2663   else
2664   {
2665 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2666     hsd->ErrorCallback(hsd);
2667 #else
2668     HAL_SD_ErrorCallback(hsd);
2669 #endif
2670   }
2671 }
2672
2673 /**
2674   * @brief  DMA SD Rx Abort callback
2675   * @param  hdma: DMA handle
2676   * @retval None
2677   */
2678 static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
2679 {
2680   SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2681   HAL_SD_CardStateTypeDef CardState;
2682
2683   /* Clear All flags */
2684   __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2685
2686   CardState = HAL_SD_GetCardState(hsd);
2687   hsd->State = HAL_SD_STATE_READY;
2688   hsd->Context = SD_CONTEXT_NONE;
2689   if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2690   {
2691     hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2692   }
2693
2694   if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
2695   {
2696 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2697     hsd->AbortCpltCallback(hsd);
2698 #else
2699     HAL_SD_AbortCallback(hsd);
2700 #endif
2701   }
2702   else
2703   {
2704 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2705     hsd->ErrorCallback(hsd);
2706 #else
2707     HAL_SD_ErrorCallback(hsd);
2708 #endif
2709   }
2710 }
2711
2712 /**
2713   * @brief  Initializes the sd card.
2714   * @param  hsd: Pointer to SD handle
2715   * @retval SD Card error state
2716   */
2717 static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
2718 {
2719   HAL_SD_CardCSDTypeDef CSD;
2720   uint32_t errorstate;
2721   uint16_t sd_rca = 1U;
2722
2723   /* Check the power State */
2724   if(SDIO_GetPowerState(hsd->Instance) == 0U)
2725   {
2726     /* Power off */
2727     return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
2728   }
2729
2730   if(hsd->SdCard.CardType != CARD_SECURED)
2731   {
2732     /* Send CMD2 ALL_SEND_CID */
2733     errorstate = SDMMC_CmdSendCID(hsd->Instance);
2734     if(errorstate != HAL_SD_ERROR_NONE)
2735     {
2736       return errorstate;
2737     }
2738     else
2739     {
2740       /* Get Card identification number data */
2741       hsd->CID[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2742       hsd->CID[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
2743       hsd->CID[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
2744       hsd->CID[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
2745     }
2746   }
2747
2748   if(hsd->SdCard.CardType != CARD_SECURED)
2749   {
2750     /* Send CMD3 SET_REL_ADDR with argument 0 */
2751     /* SD Card publishes its RCA. */
2752     errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
2753     if(errorstate != HAL_SD_ERROR_NONE)
2754     {
2755       return errorstate;
2756     }
2757   }
2758   if(hsd->SdCard.CardType != CARD_SECURED)
2759   {
2760     /* Get the SD card RCA */
2761     hsd->SdCard.RelCardAdd = sd_rca;
2762
2763     /* Send CMD9 SEND_CSD with argument as card's RCA */
2764     errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2765     if(errorstate != HAL_SD_ERROR_NONE)
2766     {
2767       return errorstate;
2768     }
2769     else
2770     {
2771       /* Get Card Specific Data */
2772       hsd->CSD[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2773       hsd->CSD[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
2774       hsd->CSD[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
2775       hsd->CSD[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
2776     }
2777   }
2778
2779   /* Get the Card Class */
2780   hsd->SdCard.Class = (SDIO_GetResponse(hsd->Instance, SDIO_RESP2) >> 20U);
2781
2782   /* Get CSD parameters */
2783   if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
2784   {
2785     return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2786   }
2787
2788   /* Select the Card */
2789   errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
2790   if(errorstate != HAL_SD_ERROR_NONE)
2791   {
2792     return errorstate;
2793   }
2794
2795   /* Configure SDIO peripheral interface */
2796   (void)SDIO_Init(hsd->Instance, hsd->Init);
2797
2798   /* All cards are initialized */
2799   return HAL_SD_ERROR_NONE;
2800 }
2801
2802 /**
2803   * @brief  Enquires cards about their operating voltage and configures clock
2804   *         controls and stores SD information that will be needed in future
2805   *         in the SD handle.
2806   * @param  hsd: Pointer to SD handle
2807   * @retval error state
2808   */
2809 static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
2810 {
2811   __IO uint32_t count = 0U;
2812   uint32_t response = 0U, validvoltage = 0U;
2813   uint32_t errorstate;
2814
2815   /* CMD0: GO_IDLE_STATE */
2816   errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2817   if(errorstate != HAL_SD_ERROR_NONE)
2818   {
2819     return errorstate;
2820   }
2821
2822   /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
2823   errorstate = SDMMC_CmdOperCond(hsd->Instance);
2824   if(errorstate != HAL_SD_ERROR_NONE)
2825   {
2826     hsd->SdCard.CardVersion = CARD_V1_X;
2827     /* CMD0: GO_IDLE_STATE */
2828     errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2829     if(errorstate != HAL_SD_ERROR_NONE)
2830     {
2831       return errorstate;
2832     }
2833
2834   }
2835   else
2836   {
2837     hsd->SdCard.CardVersion = CARD_V2_X;
2838   }
2839
2840   if( hsd->SdCard.CardVersion == CARD_V2_X)
2841   {
2842     /* SEND CMD55 APP_CMD with RCA as 0 */
2843     errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2844     if(errorstate != HAL_SD_ERROR_NONE)
2845     {
2846       return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2847     }
2848   }
2849   /* SD CARD */
2850   /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2851   while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
2852   {
2853     /* SEND CMD55 APP_CMD with RCA as 0 */
2854     errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2855     if(errorstate != HAL_SD_ERROR_NONE)
2856     {
2857       return errorstate;
2858     }
2859
2860     /* Send CMD41 */
2861     errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
2862     if(errorstate != HAL_SD_ERROR_NONE)
2863     {
2864       return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2865     }
2866
2867     /* Get command response */
2868     response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2869
2870     /* Get operating voltage*/
2871     validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
2872
2873     count++;
2874   }
2875
2876   if(count >= SDMMC_MAX_VOLT_TRIAL)
2877   {
2878     return HAL_SD_ERROR_INVALID_VOLTRANGE;
2879   }
2880
2881   if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2882   {
2883     hsd->SdCard.CardType = CARD_SDHC_SDXC;
2884   }
2885   else
2886   {
2887     hsd->SdCard.CardType = CARD_SDSC;
2888   }
2889
2890
2891   return HAL_SD_ERROR_NONE;
2892 }
2893
2894 /**
2895   * @brief  Turns the SDIO output signals off.
2896   * @param  hsd: Pointer to SD handle
2897   * @retval None
2898   */
2899 static void SD_PowerOFF(SD_HandleTypeDef *hsd)
2900 {
2901   /* Set Power State to OFF */
2902   (void)SDIO_PowerState_OFF(hsd->Instance);
2903 }
2904
2905 /**
2906   * @brief  Send Status info command.
2907   * @param  hsd: pointer to SD handle
2908   * @param  pSDstatus: Pointer to the buffer that will contain the SD card status
2909   *         SD Status register)
2910   * @retval error state
2911   */
2912 static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
2913 {
2914   SDIO_DataInitTypeDef config;
2915   uint32_t errorstate;
2916   uint32_t tickstart = HAL_GetTick();
2917   uint32_t count;
2918   uint32_t *pData = pSDstatus;
2919
2920   /* Check SD response */
2921   if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
2922   {
2923     return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
2924   }
2925
2926   /* Set block size for card if it is not equal to current block size for card */
2927   errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
2928   if(errorstate != HAL_SD_ERROR_NONE)
2929   {
2930     hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2931     return errorstate;
2932   }
2933
2934   /* Send CMD55 */
2935   errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2936   if(errorstate != HAL_SD_ERROR_NONE)
2937   {
2938     hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2939     return errorstate;
2940   }
2941
2942   /* Configure the SD DPSM (Data Path State Machine) */
2943   config.DataTimeOut   = SDMMC_DATATIMEOUT;
2944   config.DataLength    = 64U;
2945   config.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
2946   config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
2947   config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
2948   config.DPSM          = SDIO_DPSM_ENABLE;
2949   (void)SDIO_ConfigData(hsd->Instance, &config);
2950
2951   /* Send ACMD13 (SD_APP_STAUS)  with argument as card's RCA */
2952   errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
2953   if(errorstate != HAL_SD_ERROR_NONE)
2954   {
2955     hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2956     return errorstate;
2957   }
2958
2959   /* Get status data */
2960   while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
2961   {
2962     if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2963     {
2964       for(count = 0U; count < 8U; count++)
2965       {
2966         *pData = SDIO_ReadFIFO(hsd->Instance);
2967         pData++;
2968       }
2969     }
2970
2971     if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
2972     {
2973       return HAL_SD_ERROR_TIMEOUT;
2974     }
2975   }
2976
2977   if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
2978   {
2979     return HAL_SD_ERROR_DATA_TIMEOUT;
2980   }
2981   else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2982   {
2983     return HAL_SD_ERROR_DATA_CRC_FAIL;
2984   }
2985   else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2986   {
2987     return HAL_SD_ERROR_RX_OVERRUN;
2988   }
2989   else
2990   {
2991     /* Nothing to do */
2992   }
2993
2994   while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)))
2995   {
2996     *pData = SDIO_ReadFIFO(hsd->Instance);
2997     pData++;
2998
2999     if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
3000     {
3001       return HAL_SD_ERROR_TIMEOUT;
3002     }
3003   }
3004
3005   /* Clear all the static status flags*/
3006   __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
3007
3008   return HAL_SD_ERROR_NONE;
3009 }
3010
3011 /**
3012   * @brief  Returns the current card's status.
3013   * @param  hsd: Pointer to SD handle
3014   * @param  pCardStatus: pointer to the buffer that will contain the SD card
3015   *         status (Card Status register)
3016   * @retval error state
3017   */
3018 static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
3019 {
3020   uint32_t errorstate;
3021
3022   if(pCardStatus == NULL)
3023   {
3024     return HAL_SD_ERROR_PARAM;
3025   }
3026
3027   /* Send Status command */
3028   errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3029   if(errorstate != HAL_SD_ERROR_NONE)
3030   {
3031     return errorstate;
3032   }
3033
3034   /* Get SD card status */
3035   *pCardStatus = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
3036
3037   return HAL_SD_ERROR_NONE;
3038 }
3039
3040 /**
3041   * @brief  Enables the SDIO wide bus mode.
3042   * @param  hsd: pointer to SD handle
3043   * @retval error state
3044   */
3045 static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
3046 {
3047   uint32_t scr[2U] = {0U, 0U};
3048   uint32_t errorstate;
3049
3050   if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3051   {
3052     return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3053   }
3054
3055   /* Get SCR Register */
3056   errorstate = SD_FindSCR(hsd, scr);
3057   if(errorstate != HAL_SD_ERROR_NONE)
3058   {
3059     return errorstate;
3060   }
3061
3062   /* If requested card supports wide bus operation */
3063   if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
3064   {
3065     /* Send CMD55 APP_CMD with argument as card's RCA.*/
3066     errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3067     if(errorstate != HAL_SD_ERROR_NONE)
3068     {
3069       return errorstate;
3070     }
3071
3072     /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
3073     errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
3074     if(errorstate != HAL_SD_ERROR_NONE)
3075     {
3076       return errorstate;
3077     }
3078
3079     return HAL_SD_ERROR_NONE;
3080   }
3081   else
3082   {
3083     return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3084   }
3085 }
3086
3087 /**
3088   * @brief  Disables the SDIO wide bus mode.
3089   * @param  hsd: Pointer to SD handle
3090   * @retval error state
3091   */
3092 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
3093 {
3094   uint32_t scr[2U] = {0U, 0U};
3095   uint32_t errorstate;
3096
3097   if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3098   {
3099     return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3100   }
3101
3102   /* Get SCR Register */
3103   errorstate = SD_FindSCR(hsd, scr);
3104   if(errorstate != HAL_SD_ERROR_NONE)
3105   {