Fix terrible performance
[SCSI2SD-V6.git] / STM32CubeMX / SCSI2SD-V6 / Drivers / STM32F2xx_HAL_Driver / Src / stm32f2xx_hal_sd.c
1 /**
2   ******************************************************************************
3   * @file    stm32f2xx_hal_sd.c
4   * @author  MCD Application Team
5   * @version V1.1.0
6   * @date    09-October-2015
7   * @brief   SD card HAL module driver.
8   *          This file provides firmware functions to manage the following 
9   *          functionalities of the Secure Digital (SD) peripheral:
10   *           + Initialization and de-initialization functions
11   *           + IO operation functions
12   *           + Peripheral Control functions 
13   *           + Peripheral State functions
14   *         
15   @verbatim
16   ==============================================================================
17                         ##### How to use this driver #####
18   ==============================================================================
19   [..]
20     This driver implements a high level communication layer for read and write from/to 
21     this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by 
22     the user in HAL_SD_MspInit() function (MSP layer).                             
23     Basically, the MSP layer configuration should be the same as we provide in the 
24     examples.
25     You can easily tailor this configuration according to hardware resources.
26
27   [..]
28     This driver is a generic layered driver for SDIO memories which uses the HAL 
29     SDIO driver functions to interface with SD and uSD cards devices. 
30     It is used as follows:
31  
32     (#)Initialize the SDIO low level resources by implement the HAL_SD_MspInit() API:
33         (##) Enable the SDIO interface clock using __HAL_RCC_SDIO_CLK_ENABLE(); 
34         (##) SDIO pins configuration for SD card
35             (+++) Enable the clock for the SDIO GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();   
36             (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()
37                   and according to your pin assignment;
38         (##) DMA Configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
39              and HAL_SD_WriteBlocks_DMA() APIs).
40             (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE(); 
41             (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled. 
42         (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
43             (+++) Configure the SDIO and DMA interrupt priorities using functions
44                   HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority
45             (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()
46             (+++) SDIO interrupts are managed using the macros __HAL_SD_SDIO_ENABLE_IT() 
47                   and __HAL_SD_SDIO_DISABLE_IT() inside the communication process.
48             (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_SDIO_GET_IT()
49                   and __HAL_SD_SDIO_CLEAR_IT()
50     (#) At this stage, you can perform SD read/write/erase operations after SD card initialization  
51
52          
53   *** SD Card Initialization and configuration ***
54   ================================================    
55   [..]
56     To initialize the SD Card, use the HAL_SD_Init() function.  It Initializes 
57     the SD Card and put it into Standby State (Ready for data transfer). 
58     This function provide the following operations:
59   
60     (#) Apply the SD Card initialization process at 400KHz and check the SD Card 
61         type (Standard Capacity or High Capacity). You can change or adapt this 
62         frequency by adjusting the "ClockDiv" field. 
63         The SD Card frequency (SDIO_CK) is computed as follows:
64   
65            SDIO_CK = SDIOCLK / (ClockDiv + 2)
66   
67         In initialization mode and according to the SD Card standard, 
68         make sure that the SDIO_CK frequency doesn't exceed 400KHz.
69   
70     (#) Get the SD CID and CSD data. All these information are managed by the SDCardInfo 
71         structure. This structure provide also ready computed SD Card capacity 
72         and Block size.
73         
74         -@- These information are stored in SD handle structure in case of future use.  
75   
76     (#) Configure the SD Card Data transfer frequency. By Default, the card transfer 
77         frequency is set to 24MHz. You can change or adapt this frequency by adjusting 
78         the "ClockDiv" field.
79         In transfer mode and according to the SD Card standard, make sure that the 
80         SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
81         To be able to use a frequency higher than 24MHz, you should use the SDIO 
82         peripheral in bypass mode. Refer to the corresponding reference manual 
83         for more details.
84   
85     (#) Select the corresponding SD Card according to the address read with the step 2.
86     
87     (#) Configure the SD Card in wide bus mode: 4-bits data.
88   
89   *** SD Card Read operation ***
90   ==============================
91   [..] 
92     (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks(). 
93         This function support only 512-bytes block length (the block size should be 
94         chosen as 512 bytes).
95         You can choose either one block read operation or multiple block read operation 
96         by adjusting the "NumberOfBlocks" parameter.
97
98     (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
99         This function support only 512-bytes block length (the block size should be 
100         chosen as 512 bytes).
101         You can choose either one block read operation or multiple block read operation 
102         by adjusting the "NumberOfBlocks" parameter.
103         After this, you have to call the function HAL_SD_CheckReadOperation(), to insure
104         that the read transfer is done correctly in both DMA and SD sides.
105   
106   *** SD Card Write operation ***
107   =============================== 
108   [..] 
109     (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks(). 
110         This function support only 512-bytes block length (the block size should be 
111         chosen as 512 bytes).
112         You can choose either one block read operation or multiple block read operation 
113         by adjusting the "NumberOfBlocks" parameter.
114
115     (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
116         This function support only 512-bytes block length (the block size should be 
117         chosen as 512 byte).
118         You can choose either one block read operation or multiple block read operation 
119         by adjusting the "NumberOfBlocks" parameter.
120         After this, you have to call the function HAL_SD_CheckWriteOperation(), to insure
121         that the write transfer is done correctly in both DMA and SD sides.  
122   
123   *** SD card status ***
124   ====================== 
125   [..]
126     (+) At any time, you can check the SD Card status and get the SD card state 
127         by using the HAL_SD_GetStatus() function. This function checks first if the 
128         SD card is still connected and then get the internal SD Card transfer state.     
129     (+) You can also get the SD card SD Status register by using the HAL_SD_SendSDStatus() 
130         function.    
131
132   *** SD HAL driver macros list ***
133   ==================================
134   [..]
135     Below the list of most used macros in SD HAL driver.
136
137     (+) __HAL_SD_SDIO_ENABLE : Enable the SD device
138     (+) __HAL_SD_SDIO_DISABLE : Disable the SD device
139     (+) __HAL_SD_SDIO_DMA_ENABLE: Enable the SDIO DMA transfer
140     (+) __HAL_SD_SDIO_DMA_DISABLE: Disable the SDIO DMA transfer
141     (+) __HAL_SD_SDIO_ENABLE_IT: Enable the SD device interrupt
142     (+) __HAL_SD_SDIO_DISABLE_IT: Disable the SD device interrupt
143     (+) __HAL_SD_SDIO_GET_FLAG:Check whether the specified SD flag is set or not
144     (+) __HAL_SD_SDIO_CLEAR_FLAG: Clear the SD's pending flags
145       
146     (@) You can refer to the SD HAL driver header file for more useful macros 
147       
148   @endverbatim
149   ******************************************************************************
150   * @attention
151   *
152   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
153   *
154   * Redistribution and use in source and binary forms, with or without modification,
155   * are permitted provided that the following conditions are met:
156   *   1. Redistributions of source code must retain the above copyright notice,
157   *      this list of conditions and the following disclaimer.
158   *   2. Redistributions in binary form must reproduce the above copyright notice,
159   *      this list of conditions and the following disclaimer in the documentation
160   *      and/or other materials provided with the distribution.
161   *   3. Neither the name of STMicroelectronics nor the names of its contributors
162   *      may be used to endorse or promote products derived from this software
163   *      without specific prior written permission.
164   *
165   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
166   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
167   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
168   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
169   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
170   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
171   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
172   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
173   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
174   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
175   *
176   ******************************************************************************
177   */ 
178
179 /* Includes ------------------------------------------------------------------*/
180 #include "stm32f2xx_hal.h"
181 #ifdef HAL_SD_MODULE_ENABLED
182
183 /** @addtogroup STM32F2xx_HAL_Driver
184   * @{
185   */
186
187 /** @addtogroup SD 
188   * @{
189   */
190
191 /* Private typedef -----------------------------------------------------------*/
192 /* Private define ------------------------------------------------------------*/
193 /** @addtogroup SD_Private_Defines
194   * @{
195   */
196 /** 
197   * @brief  SDIO Data block size 
198   */ 
199 #define DATA_BLOCK_SIZE                  ((uint32_t)(9 << 4))
200 /** 
201   * @brief  SDIO Static flags, Timeout, FIFO Address  
202   */
203 #define SDIO_STATIC_FLAGS               ((uint32_t)(SDIO_FLAG_CCRCFAIL | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_CTIMEOUT |\
204                                                     SDIO_FLAG_DTIMEOUT | SDIO_FLAG_TXUNDERR | SDIO_FLAG_RXOVERR  |\
205                                                     SDIO_FLAG_CMDREND  | SDIO_FLAG_CMDSENT  | SDIO_FLAG_DATAEND  |\
206                                                     SDIO_FLAG_DBCKEND))  
207
208 #define SDIO_CMD0TIMEOUT                ((uint32_t)0x00010000)
209
210 /** 
211   * @brief  Mask for errors Card Status R1 (OCR Register) 
212   */
213 #define SD_OCR_ADDR_OUT_OF_RANGE        ((uint32_t)0x80000000)
214 #define SD_OCR_ADDR_MISALIGNED          ((uint32_t)0x40000000)
215 #define SD_OCR_BLOCK_LEN_ERR            ((uint32_t)0x20000000)
216 #define SD_OCR_ERASE_SEQ_ERR            ((uint32_t)0x10000000)
217 #define SD_OCR_BAD_ERASE_PARAM          ((uint32_t)0x08000000)
218 #define SD_OCR_WRITE_PROT_VIOLATION     ((uint32_t)0x04000000)
219 #define SD_OCR_LOCK_UNLOCK_FAILED       ((uint32_t)0x01000000)
220 #define SD_OCR_COM_CRC_FAILED           ((uint32_t)0x00800000)
221 #define SD_OCR_ILLEGAL_CMD              ((uint32_t)0x00400000)
222 #define SD_OCR_CARD_ECC_FAILED          ((uint32_t)0x00200000)
223 #define SD_OCR_CC_ERROR                 ((uint32_t)0x00100000)
224 #define SD_OCR_GENERAL_UNKNOWN_ERROR    ((uint32_t)0x00080000)
225 #define SD_OCR_STREAM_READ_UNDERRUN     ((uint32_t)0x00040000)
226 #define SD_OCR_STREAM_WRITE_OVERRUN     ((uint32_t)0x00020000)
227 #define SD_OCR_CID_CSD_OVERWRITE       ((uint32_t)0x00010000)
228 #define SD_OCR_WP_ERASE_SKIP            ((uint32_t)0x00008000)
229 #define SD_OCR_CARD_ECC_DISABLED        ((uint32_t)0x00004000)
230 #define SD_OCR_ERASE_RESET              ((uint32_t)0x00002000)
231 #define SD_OCR_AKE_SEQ_ERROR            ((uint32_t)0x00000008)
232 #define SD_OCR_ERRORBITS                ((uint32_t)0xFDFFE008)
233
234 /** 
235   * @brief  Masks for R6 Response 
236   */
237 #define SD_R6_GENERAL_UNKNOWN_ERROR     ((uint32_t)0x00002000)
238 #define SD_R6_ILLEGAL_CMD               ((uint32_t)0x00004000)
239 #define SD_R6_COM_CRC_FAILED            ((uint32_t)0x00008000)
240
241 #define SD_VOLTAGE_WINDOW_SD            ((uint32_t)0x80100000)
242 #define SD_HIGH_CAPACITY                ((uint32_t)0x40000000)
243 #define SD_STD_CAPACITY                 ((uint32_t)0x00000000)
244 #define SD_CHECK_PATTERN                ((uint32_t)0x000001AA)
245
246 #define SD_MAX_VOLT_TRIAL               ((uint32_t)0x0000FFFF)
247 #define SD_ALLZERO                      ((uint32_t)0x00000000)
248
249 #define SD_WIDE_BUS_SUPPORT             ((uint32_t)0x00040000)
250 #define SD_SINGLE_BUS_SUPPORT           ((uint32_t)0x00010000)
251 #define SD_CARD_LOCKED                  ((uint32_t)0x02000000)
252
253 #define SD_DATATIMEOUT                  ((uint32_t)0xFFFFFFFF)
254 #define SD_0TO7BITS                     ((uint32_t)0x000000FF)
255 #define SD_8TO15BITS                    ((uint32_t)0x0000FF00)
256 #define SD_16TO23BITS                   ((uint32_t)0x00FF0000)
257 #define SD_24TO31BITS                   ((uint32_t)0xFF000000)
258 #define SD_MAX_DATA_LENGTH              ((uint32_t)0x01FFFFFF)
259
260 #define SD_HALFFIFO                     ((uint32_t)0x00000008)
261 #define SD_HALFFIFOBYTES                ((uint32_t)0x00000020)
262
263 /** 
264   * @brief  Command Class Supported 
265   */
266 #define SD_CCCC_LOCK_UNLOCK             ((uint32_t)0x00000080)
267 #define SD_CCCC_WRITE_PROT              ((uint32_t)0x00000040)
268 #define SD_CCCC_ERASE                   ((uint32_t)0x00000020)
269
270 /** 
271   * @brief  Following commands are SD Card Specific commands.
272   *         SDIO_APP_CMD should be sent before sending these commands. 
273   */
274 #define SD_SDIO_SEND_IF_COND            ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
275
276 /**
277   * @}
278   */
279   
280 /* Private macro -------------------------------------------------------------*/
281 /* Private variables ---------------------------------------------------------*/
282 /* Private function prototypes -----------------------------------------------*/
283 /** @addtogroup SD_Private_Functions_Prototypes
284   * @{
285   */
286 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
287 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
288 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd); 
289 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
290 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
291 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
292 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
293 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
294 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
295 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
296 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
297 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
298 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
299 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
300 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
301 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);  
302 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
303 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
304 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
305 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
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  
326 @endverbatim
327   * @{
328   */
329
330 /**
331   * @brief  Initializes the SD card according to the specified parameters in the 
332             SD_HandleTypeDef and create the associated handle.
333   * @param  hsd: SD handle
334   * @param  SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information   
335   * @retval HAL SD error state
336   */
337 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
338
339   __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
340   SD_InitTypeDef tmpinit;
341   
342   /* Allocate lock resource and initialize it */
343   hsd->Lock = HAL_UNLOCKED;
344   /* Initialize the low level hardware (MSP) */
345   HAL_SD_MspInit(hsd);
346   
347   /* Default SDIO peripheral configuration for SD card initialization */
348   tmpinit.ClockEdge           = SDIO_CLOCK_EDGE_RISING;
349   tmpinit.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;
350   tmpinit.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_DISABLE;
351   tmpinit.BusWide             = SDIO_BUS_WIDE_1B;
352   tmpinit.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
353   tmpinit.ClockDiv            = SDIO_INIT_CLK_DIV;
354   
355   /* Initialize SDIO peripheral interface with default configuration */
356   SDIO_Init(hsd->Instance, tmpinit);
357   
358   /* Identify card operating voltage */
359   errorstate = SD_PowerON(hsd); 
360   
361   if(errorstate != SD_OK)     
362   {
363     return errorstate;
364   }
365   
366   /* Initialize the present SDIO card(s) and put them in idle state */
367   errorstate = SD_Initialize_Cards(hsd);
368   
369   if (errorstate != SD_OK)
370   {
371     return errorstate;
372   }
373   
374   /* Read CSD/CID MSD registers */
375   errorstate = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
376   
377   if (errorstate == SD_OK)
378   {
379     /* Select the Card */
380     errorstate = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
381   }
382   
383   /* Configure SDIO peripheral interface */
384   SDIO_Init(hsd->Instance, hsd->Init);   
385   
386   return errorstate;
387 }
388
389 /**
390   * @brief  De-Initializes the SD card.
391   * @param  hsd: SD handle
392   * @retval HAL status
393   */
394 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
395 {
396   
397   /* Set SD power state to off */ 
398   SD_PowerOFF(hsd);
399   
400   /* De-Initialize the MSP layer */
401   HAL_SD_MspDeInit(hsd);
402   
403   return HAL_OK;
404 }
405
406
407 /**
408   * @brief  Initializes the SD MSP.
409   * @param  hsd: SD handle
410   * @retval None
411   */
412 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
413 {
414   /* NOTE : This function Should not be modified, when the callback is needed,
415             the HAL_SD_MspInit could be implemented in the user file
416    */
417 }
418
419 /**
420   * @brief  De-Initialize SD MSP.
421   * @param  hsd: SD handle
422   * @retval None
423   */
424 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
425 {
426   /* NOTE : This function Should not be modified, when the callback is needed,
427             the HAL_SD_MspDeInit could be implemented in the user file
428    */
429 }
430
431 /**
432   * @}
433   */
434
435 /** @addtogroup SD_Exported_Functions_Group2
436  *  @brief   Data transfer functions 
437  *
438 @verbatim   
439   ==============================================================================
440                         ##### IO operation functions #####
441   ==============================================================================  
442   [..]
443     This subsection provides a set of functions allowing to manage the data 
444     transfer from/to SD card.
445
446 @endverbatim
447   * @{
448   */
449
450 /**
451   * @brief  Reads block(s) from a specified address in a card. The Data transfer 
452   *         is managed by polling mode.  
453   * @param  hsd: SD handle
454   * @param  pReadBuffer: pointer to the buffer that will contain the received data
455   * @param  ReadAddr: Address from where data is to be read  
456   * @param  BlockSize: SD card Data block size 
457   * @note   BlockSize must be 512 bytes.
458   * @param  NumberOfBlocks: Number of SD blocks to read   
459   * @retval SD Card error state
460   */
461 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
462 {
463   SDIO_CmdInitTypeDef  sdio_cmdinitstructure;
464   SDIO_DataInitTypeDef sdio_datainitstructure;
465   HAL_SD_ErrorTypedef errorstate = SD_OK;
466   uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
467   
468   /* Initialize data control register */
469   hsd->Instance->DCTRL = 0;
470   
471   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
472   {
473     BlockSize = 512;
474     ReadAddr /= 512;
475   }
476   
477   /* Set Block Size for Card */ 
478   sdio_cmdinitstructure.Argument         = (uint32_t) BlockSize;
479   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
480   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
481   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
482   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
483   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
484   
485   /* Check for error conditions */
486   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
487   
488   if (errorstate != SD_OK)
489   {
490     return errorstate;
491   }
492   
493   /* Configure the SD DPSM (Data Path State Machine) */
494   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
495   sdio_datainitstructure.DataLength    = NumberOfBlocks * BlockSize;
496   sdio_datainitstructure.DataBlockSize = DATA_BLOCK_SIZE;
497   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
498   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
499   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
500   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
501   
502   if(NumberOfBlocks > 1)
503   {
504     /* Send CMD18 READ_MULT_BLOCK with argument data address */
505     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
506   }
507   else
508   {
509     /* Send CMD17 READ_SINGLE_BLOCK */
510     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;    
511   }
512   
513   sdio_cmdinitstructure.Argument         = (uint32_t)ReadAddr;
514   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
515   
516   /* Read block(s) in polling mode */
517   if(NumberOfBlocks > 1)
518   {
519     /* Check for error conditions */
520     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
521     
522     if (errorstate != SD_OK)
523     {
524       return errorstate;
525     }
526     
527     /* Poll on SDIO flags */
528     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
529     {
530       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
531       {
532         /* Read data from SDIO Rx FIFO */
533         for (count = 0; count < 8; count++)
534         {
535           *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
536         }
537         
538         tempbuff += 8;
539       }
540     }      
541   }
542   else
543   {
544     /* Check for error conditions */
545     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK); 
546     
547     if (errorstate != SD_OK)
548     {
549       return errorstate;
550     }    
551     
552     /* In case of single block transfer, no need of stop transfer at all */
553     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
554     {
555       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
556       {
557         /* Read data from SDIO Rx FIFO */
558         for (count = 0; count < 8; count++)
559         {
560           *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
561         }
562         
563         tempbuff += 8;
564       }
565     }
566   }
567   
568   /* Send stop transmission command in case of multiblock read */
569   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
570   {    
571     if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
572       (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
573         (hsd->CardType == HIGH_CAPACITY_SD_CARD))
574     {
575       /* Send stop transmission command */
576       errorstate = HAL_SD_StopTransfer(hsd);
577     }
578   }
579   
580   /* Get error state */
581   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
582   {
583     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
584     
585     errorstate = SD_DATA_TIMEOUT;
586     
587     return errorstate;
588   }
589   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
590   {
591     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
592     
593     errorstate = SD_DATA_CRC_FAIL;
594     
595     return errorstate;
596   }
597   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
598   {
599     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
600     
601     errorstate = SD_RX_OVERRUN;
602     
603     return errorstate;
604   }
605   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
606   {
607     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
608     
609     errorstate = SD_START_BIT_ERR;
610     
611     return errorstate;
612   }
613   else
614   {
615     /* No error flag set */
616   }
617   
618   count = SD_DATATIMEOUT;
619   
620   /* Empty FIFO if there is still any data */
621   while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
622   {
623     *tempbuff = SDIO_ReadFIFO(hsd->Instance);
624     tempbuff++;
625     count--;
626   }
627   
628   /* Clear all the static flags */
629   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
630   
631   return errorstate;
632 }
633
634 /**
635   * @brief  Allows to write block(s) to a specified address in a card. The Data
636   *         transfer is managed by polling mode.  
637   * @param  hsd: SD handle
638   * @param  pWriteBuffer: pointer to the buffer that will contain the data to transmit
639   * @param  WriteAddr: Address from where data is to be written 
640   * @param  BlockSize: SD card Data block size 
641   * @note   BlockSize must be 512 bytes.
642   * @param  NumberOfBlocks: Number of SD blocks to write 
643   * @retval SD Card error state
644   */
645 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
646 {
647   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
648   SDIO_DataInitTypeDef sdio_datainitstructure;
649   HAL_SD_ErrorTypedef errorstate = SD_OK;
650   uint32_t totalnumberofbytes = 0, bytestransferred = 0, count = 0, restwords = 0;
651   uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
652   uint8_t cardstate  = 0;
653   
654   /* Initialize data control register */
655   hsd->Instance->DCTRL = 0;
656   
657   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
658   {
659     BlockSize = 512;
660     WriteAddr /= 512;
661   }
662   
663   /* Set Block Size for Card */ 
664   sdio_cmdinitstructure.Argument         = (uint32_t)BlockSize;
665   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
666   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
667   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
668   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
669   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
670   
671   /* Check for error conditions */
672   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
673   
674   if (errorstate != SD_OK)
675   {
676     return errorstate;
677   }
678   
679   if(NumberOfBlocks > 1)
680   {
681     /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
682     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
683   }
684   else
685   {
686     /* Send CMD24 WRITE_SINGLE_BLOCK */
687     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
688   }
689   
690   sdio_cmdinitstructure.Argument         = (uint32_t)WriteAddr;
691   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
692   
693   /* Check for error conditions */
694   if(NumberOfBlocks > 1)
695   {
696     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
697   }
698   else
699   {
700     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
701   }  
702   
703   if (errorstate != SD_OK)
704   {
705     return errorstate;
706   }
707   
708   /* Set total number of bytes to write */
709   totalnumberofbytes = NumberOfBlocks * BlockSize;
710   
711   /* Configure the SD DPSM (Data Path State Machine) */ 
712   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
713   sdio_datainitstructure.DataLength    = NumberOfBlocks * BlockSize;
714   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
715   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
716   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
717   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
718   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
719   
720   /* Write block(s) in polling mode */
721   if(NumberOfBlocks > 1)
722   {
723     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
724     {
725       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
726       {
727         if ((totalnumberofbytes - bytestransferred) < 32)
728         {
729           restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes -  bytestransferred) / 4 + 1);
730           
731           /* Write data to SDIO Tx FIFO */
732           for (count = 0; count < restwords; count++)
733           {
734             SDIO_WriteFIFO(hsd->Instance, tempbuff);
735             tempbuff++;
736             bytestransferred += 4;
737           }
738         }
739         else
740         {
741           /* Write data to SDIO Tx FIFO */
742           for (count = 0; count < 8; count++)
743           {
744             SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
745           }
746           
747           tempbuff += 8;
748           bytestransferred += 32;
749         }
750       }
751     }   
752   }
753   else
754   {
755     /* In case of single data block transfer no need of stop command at all */
756     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
757     {
758       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))
759       {
760         if ((totalnumberofbytes - bytestransferred) < 32)
761         {
762           restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes -  bytestransferred) / 4 + 1);
763           
764           /* Write data to SDIO Tx FIFO */
765           for (count = 0; count < restwords; count++)
766           {
767             SDIO_WriteFIFO(hsd->Instance, tempbuff);
768             tempbuff++; 
769             bytestransferred += 4;
770           }
771         }
772         else
773         {
774           /* Write data to SDIO Tx FIFO */
775           for (count = 0; count < 8; count++)
776           {
777             SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));
778           }
779           
780           tempbuff += 8;
781           bytestransferred += 32;
782         }
783       }
784     }  
785   }
786   
787   /* Send stop transmission command in case of multiblock write */
788   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1))
789   {    
790     if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
791       (hsd->CardType == HIGH_CAPACITY_SD_CARD))
792     {
793       /* Send stop transmission command */
794       errorstate = HAL_SD_StopTransfer(hsd);
795     }
796   }
797   
798   /* Get error state */
799   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
800   {
801     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
802     
803     errorstate = SD_DATA_TIMEOUT;
804     
805     return errorstate;
806   }
807   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
808   {
809     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
810     
811     errorstate = SD_DATA_CRC_FAIL;
812     
813     return errorstate;
814   }
815   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
816   {
817     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
818     
819     errorstate = SD_TX_UNDERRUN;
820     
821     return errorstate;
822   }
823   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
824   {
825     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
826     
827     errorstate = SD_START_BIT_ERR;
828     
829     return errorstate;
830   }
831   else
832   {
833     /* No error flag set */
834   }
835   
836   /* Clear all the static flags */
837   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
838   
839   /* Wait till the card is in programming state */
840   errorstate = SD_IsCardProgramming(hsd, &cardstate);
841   
842   while ((errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
843   {
844     errorstate = SD_IsCardProgramming(hsd, &cardstate);
845   }
846   
847   return errorstate;
848 }
849
850 /**
851   * @brief  Reads block(s) from a specified address in a card. The Data transfer 
852   *         is managed by DMA mode. 
853   * @note   This API should be followed by the function HAL_SD_CheckReadOperation()
854   *         to check the completion of the read process   
855   * @param  hsd: SD handle                 
856   * @param  pReadBuffer: Pointer to the buffer that will contain the received data
857   * @param  ReadAddr: Address from where data is to be read  
858   * @param  BlockSize: SD card Data block size 
859   * @note   BlockSize must be 512 bytes.
860   * @param  NumberOfBlocks: Number of blocks to read.
861   * @retval SD Card error state
862   */
863 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
864 {
865   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
866   SDIO_DataInitTypeDef sdio_datainitstructure;
867   HAL_SD_ErrorTypedef errorstate = SD_OK;
868   
869   /* Initialize data control register */
870   hsd->Instance->DCTRL = 0;
871   
872   /* Initialize handle flags */
873   hsd->SdTransferCplt  = 0;
874   hsd->DmaTransferCplt = 0;
875   hsd->SdTransferErr   = SD_OK; 
876   
877   /* Initialize SD Read operation */
878   if(NumberOfBlocks > 1)
879   {
880     hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
881   }
882   else
883   {
884     hsd->SdOperation = SD_READ_SINGLE_BLOCK;
885   }
886   
887   /* Enable transfer interrupts */
888   __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
889                                 SDIO_IT_DTIMEOUT |\
890                                 SDIO_IT_DATAEND  |\
891                                 SDIO_IT_RXOVERR  |\
892                                 SDIO_IT_STBITERR));
893   
894   /* Enable SDIO DMA transfer */
895   __HAL_SD_SDIO_DMA_ENABLE();
896   
897   /* Configure DMA user callbacks */
898   hsd->hdmarx->XferCpltCallback  = SD_DMA_RxCplt;
899   hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
900   
901   /* Enable the DMA Stream */
902   HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks)/4);
903   
904   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
905   {
906     BlockSize = 512;
907     ReadAddr /= 512;
908   }
909   
910   /* Set Block Size for Card */ 
911   sdio_cmdinitstructure.Argument         = (uint32_t)BlockSize;
912   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
913   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
914   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
915   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
916   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
917   
918   /* Check for error conditions */
919   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
920   
921   if (errorstate != SD_OK)
922   {
923     return errorstate;
924   }
925   
926   /* Configure the SD DPSM (Data Path State Machine) */ 
927   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
928   sdio_datainitstructure.DataLength    = BlockSize * NumberOfBlocks;
929   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
930   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
931   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
932   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
933   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
934   
935   /* Check number of blocks command */
936   if(NumberOfBlocks > 1)
937   {
938     /* Send CMD18 READ_MULT_BLOCK with argument data address */
939     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
940   }
941   else
942   {
943     /* Send CMD17 READ_SINGLE_BLOCK */
944     sdio_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
945   }
946   
947   sdio_cmdinitstructure.Argument = (uint32_t)ReadAddr;
948   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
949   
950   /* Check for error conditions */
951   if(NumberOfBlocks > 1)
952   {
953     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
954   }
955   else
956   {
957     errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
958   }
959   
960   /* Update the SD transfer error in SD handle */
961   hsd->SdTransferErr = errorstate;
962   
963   return errorstate;
964 }
965
966
967 /**
968   * @brief  Writes block(s) to a specified address in a card. The Data transfer 
969   *         is managed by DMA mode. 
970   * @note   This API should be followed by the function HAL_SD_CheckWriteOperation()
971   *         to check the completion of the write process (by SD current status polling).  
972   * @param  hsd: SD handle
973   * @param  pWriteBuffer: pointer to the buffer that will contain the data to transmit
974   * @param  WriteAddr: Address from where data is to be read   
975   * @param  BlockSize: the SD card Data block size 
976   * @note   BlockSize must be 512 bytes.
977   * @param  NumberOfBlocks: Number of blocks to write
978   * @retval SD Card error state
979   */
980 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
981 {
982   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
983   SDIO_DataInitTypeDef sdio_datainitstructure;
984   HAL_SD_ErrorTypedef errorstate = SD_OK;
985   
986   /* Initialize data control register */
987   hsd->Instance->DCTRL = 0;
988   
989   /* Initialize handle flags */
990   hsd->SdTransferCplt  = 0;
991   hsd->DmaTransferCplt = 0;
992   hsd->SdTransferErr   = SD_OK;
993   
994   /* Initialize SD Write operation */
995   if(NumberOfBlocks > 1)
996   {
997     hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
998   }
999   else
1000   {
1001     hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
1002   }  
1003   
1004   /* Enable transfer interrupts */
1005   __HAL_SD_SDIO_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL |\
1006                                 SDIO_IT_DTIMEOUT |\
1007                                 SDIO_IT_DATAEND  |\
1008                                 SDIO_IT_TXUNDERR |\
1009                                 SDIO_IT_STBITERR));
1010   
1011   /* Configure DMA user callbacks */
1012   hsd->hdmatx->XferCpltCallback  = SD_DMA_TxCplt;
1013   hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
1014   
1015   /* Enable the DMA Stream */
1016   HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BlockSize * NumberOfBlocks)/4);
1017
1018   /* Enable SDIO DMA transfer */
1019   __HAL_SD_SDIO_DMA_ENABLE();
1020   
1021   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1022   {
1023     BlockSize = 512;
1024     WriteAddr /= 512;
1025   }
1026
1027   /* Set Block Size for Card */ 
1028   sdio_cmdinitstructure.Argument         = (uint32_t)BlockSize;
1029   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
1030   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1031   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1032   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1033   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1034
1035   /* Check for error conditions */
1036   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1037
1038   if (errorstate != SD_OK)
1039   {
1040     return errorstate;
1041   }
1042   
1043   /* Check number of blocks command */
1044   if(NumberOfBlocks <= 1)
1045   {
1046     /* Send CMD24 WRITE_SINGLE_BLOCK */
1047     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
1048   }
1049   else
1050   {
1051     /* MM: Prepare for write */
1052     /* Set Block Size for Card */ 
1053     sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
1054     sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
1055     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1056     errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
1057     if (errorstate != SD_OK)
1058     {
1059       return errorstate;
1060     }
1061     sdio_cmdinitstructure.Argument         = (uint32_t)NumberOfBlocks;
1062     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCK_COUNT;
1063     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1064     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCK_COUNT);
1065     if (errorstate != SD_OK)
1066     {
1067       return errorstate;
1068     }
1069   
1070     /* /MM */
1071
1072     /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
1073     sdio_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
1074   }
1075   
1076   sdio_cmdinitstructure.Argument         = (uint32_t)WriteAddr;
1077   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1078
1079   /* Check for error conditions */
1080   if(NumberOfBlocks > 1)
1081   {
1082     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
1083   }
1084   else
1085   {
1086     errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
1087   }
1088   
1089   if (errorstate != SD_OK)
1090   {
1091     return errorstate;
1092   }
1093   
1094   /* Configure the SD DPSM (Data Path State Machine) */ 
1095   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
1096   sdio_datainitstructure.DataLength    = BlockSize * NumberOfBlocks;
1097   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1098   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
1099   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1100   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
1101   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1102   
1103   hsd->SdTransferErr = errorstate;
1104   
1105   return errorstate;
1106 }
1107
1108 /**
1109   * @brief  This function waits until the SD DMA data read transfer is finished. 
1110   *         This API should be called after HAL_SD_ReadBlocks_DMA() function
1111   *         to insure that all data sent by the card is already transferred by the 
1112   *         DMA controller.
1113   * @param  hsd: SD handle
1114   * @param  Timeout: Timeout duration  
1115   * @retval SD Card error state
1116   */
1117 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1118 {
1119   HAL_SD_ErrorTypedef errorstate = SD_OK;
1120   uint32_t timeout = Timeout;
1121   uint32_t tmp1, tmp2;
1122   HAL_SD_ErrorTypedef tmp3;
1123   
1124   /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1125   tmp1 = hsd->DmaTransferCplt; 
1126   tmp2 = hsd->SdTransferCplt;
1127   tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1128     
1129   while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1130   {
1131     tmp1 = hsd->DmaTransferCplt; 
1132     tmp2 = hsd->SdTransferCplt;
1133     tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;    
1134     timeout--;
1135   }
1136   
1137   timeout = Timeout;
1138   
1139   /* Wait until the Rx transfer is no longer active. IE. fifo is empty.
1140 Once FIFO is empty, the DMA will have finished and DmaTransferCplt should
1141 be true */
1142   while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXACT)) && (timeout > 0))
1143   {
1144     timeout--;  
1145   }
1146   
1147   /* Send stop command in multiblock read */
1148   if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
1149   {
1150     errorstate = HAL_SD_StopTransfer(hsd);
1151   }
1152   
1153   if ((timeout == 0) && (errorstate == SD_OK))
1154   {
1155     errorstate = SD_DATA_TIMEOUT;
1156   }
1157   
1158   /* Clear all the static flags */
1159   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1160   
1161   /* Return error state */
1162   if (hsd->SdTransferErr != SD_OK)
1163   {
1164     return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1165   }
1166   
1167   return errorstate;
1168 }
1169
1170 /**
1171   * @brief  This function waits until the SD DMA data write transfer is finished. 
1172   *         This API should be called after HAL_SD_WriteBlocks_DMA() function
1173   *         to insure that all data sent by the card is already transferred by the 
1174   *         DMA controller.
1175   * @param  hsd: SD handle
1176   * @param  Timeout: Timeout duration  
1177   * @retval SD Card error state
1178   */
1179 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
1180 {
1181   HAL_SD_ErrorTypedef errorstate = SD_OK;
1182   uint32_t timeout = Timeout;
1183   uint32_t tmp1, tmp2;
1184   HAL_SD_ErrorTypedef tmp3;
1185
1186   /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
1187   tmp1 = hsd->DmaTransferCplt; 
1188   tmp2 = hsd->SdTransferCplt;
1189   tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1190     
1191   while ((tmp1 == 0) && (tmp2 == 0) && (tmp3 == SD_OK) && (timeout > 0))
1192   {
1193     tmp1 = hsd->DmaTransferCplt; 
1194     tmp2 = hsd->SdTransferCplt;
1195     tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
1196     timeout--;
1197   }
1198   
1199   timeout = Timeout;
1200   
1201   /* Wait until the Tx transfer is no longer active */
1202   while((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_TXACT))  && (timeout > 0))
1203   {
1204     timeout--;  
1205   }
1206
1207   /* Send stop command in multiblock write */
1208   if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
1209   {
1210     errorstate = HAL_SD_StopTransfer(hsd);
1211   }
1212   
1213   if ((timeout == 0) && (errorstate == SD_OK))
1214   {
1215     errorstate = SD_DATA_TIMEOUT;
1216   }
1217   
1218   /* Clear all the static flags */
1219   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1220   
1221   /* Return error state */
1222   if (hsd->SdTransferErr != SD_OK)
1223   {
1224     return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
1225   }
1226   
1227   /* Wait until write is complete */
1228   while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
1229   {    
1230   }
1231
1232   return errorstate; 
1233 }
1234
1235 /**
1236   * @brief  Erases the specified memory area of the given SD card.
1237   * @param  hsd: SD handle 
1238   * @param  startaddr: Start byte address
1239   * @param  endaddr: End byte address
1240   * @retval SD Card error state
1241   */
1242 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
1243 {
1244   HAL_SD_ErrorTypedef errorstate = SD_OK;
1245   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1246   
1247   uint32_t delay         = 0;
1248   __IO uint32_t maxdelay = 0;
1249   uint8_t cardstate      = 0;
1250   
1251   /* Check if the card command class supports erase command */
1252   if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
1253   {
1254     errorstate = SD_REQUEST_NOT_APPLICABLE;
1255     
1256     return errorstate;
1257   }
1258   
1259   /* Get max delay value */
1260   maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
1261   
1262   if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1263   {
1264     errorstate = SD_LOCK_UNLOCK_FAILED;
1265     
1266     return errorstate;
1267   }
1268   
1269   /* Get start and end block for high capacity cards */
1270   if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1271   {
1272     startaddr /= 512;
1273     endaddr   /= 512;
1274   }
1275   
1276   /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1277   if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1278     (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1279   {
1280     /* Send CMD32 SD_ERASE_GRP_START with argument as addr  */
1281     sdio_cmdinitstructure.Argument         =(uint32_t)startaddr;
1282     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_ERASE_GRP_START;
1283     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1284     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1285     sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1286     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1287     
1288     /* Check for error conditions */
1289     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
1290     
1291     if (errorstate != SD_OK)
1292     {
1293       return errorstate;
1294     }
1295     
1296     /* Send CMD33 SD_ERASE_GRP_END with argument as addr  */
1297     sdio_cmdinitstructure.Argument         = (uint32_t)endaddr;
1298     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_ERASE_GRP_END;
1299     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1300     
1301     /* Check for error conditions */
1302     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
1303     
1304     if (errorstate != SD_OK)
1305     {
1306       return errorstate;
1307     }
1308   }
1309   
1310   /* Send CMD38 ERASE */
1311   sdio_cmdinitstructure.Argument         = 0;
1312   sdio_cmdinitstructure.CmdIndex         = SD_CMD_ERASE;
1313   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1314   
1315   /* Check for error conditions */
1316   errorstate = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
1317   
1318   if (errorstate != SD_OK)
1319   {
1320     return errorstate;
1321   }
1322   
1323   for (; delay < maxdelay; delay++)
1324   {
1325   }
1326   
1327   /* Wait until the card is in programming state */
1328   errorstate = SD_IsCardProgramming(hsd, &cardstate);
1329   
1330   delay = SD_DATATIMEOUT;
1331   
1332   while ((delay > 0) && (errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
1333   {
1334     errorstate = SD_IsCardProgramming(hsd, &cardstate);
1335     delay--;
1336   }
1337   
1338   return errorstate;
1339 }
1340
1341 /**
1342   * @brief  This function handles SD card interrupt request.
1343   * @param  hsd: SD handle
1344   * @retval None
1345   */
1346 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1347 {  
1348   /* Check for SDIO interrupt flags */
1349   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DATAEND))
1350   {
1351     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_IT_DATAEND);  
1352       
1353     /* SD transfer is complete */
1354     hsd->SdTransferCplt = 1;
1355
1356     /* No transfer error */ 
1357     hsd->SdTransferErr  = SD_OK;
1358
1359     HAL_SD_XferCpltCallback(hsd);  
1360   }  
1361   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DCRCFAIL))
1362   {
1363     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1364     
1365     hsd->SdTransferErr = SD_DATA_CRC_FAIL;
1366     
1367     HAL_SD_XferErrorCallback(hsd);
1368     
1369   }
1370   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_DTIMEOUT))
1371   {
1372     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1373     
1374     hsd->SdTransferErr = SD_DATA_TIMEOUT;
1375     
1376     HAL_SD_XferErrorCallback(hsd);
1377   }
1378   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_RXOVERR))
1379   {
1380     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1381     
1382     hsd->SdTransferErr = SD_RX_OVERRUN;
1383     
1384     HAL_SD_XferErrorCallback(hsd);
1385   }
1386   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_TXUNDERR))
1387   {
1388     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_TXUNDERR);
1389     
1390     hsd->SdTransferErr = SD_TX_UNDERRUN;
1391     
1392     HAL_SD_XferErrorCallback(hsd);
1393   }
1394   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_IT_STBITERR))
1395   {
1396     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1397     
1398     hsd->SdTransferErr = SD_START_BIT_ERR;
1399     
1400     HAL_SD_XferErrorCallback(hsd);
1401   }
1402   else
1403   {
1404     /* No error flag set */
1405   }
1406
1407   /* Disable all SDIO peripheral interrupt sources */
1408   __HAL_SD_SDIO_DISABLE_IT(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND  |\
1409                                 SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |\
1410                                 SDIO_IT_RXOVERR  | SDIO_IT_STBITERR);                               
1411 }
1412
1413
1414 /**
1415   * @brief  SD end of transfer callback.
1416   * @param  hsd: SD handle 
1417   * @retval None
1418   */
1419 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
1420 {
1421   /* NOTE : This function Should not be modified, when the callback is needed,
1422             the HAL_SD_XferCpltCallback could be implemented in the user file
1423    */ 
1424 }
1425
1426 /**
1427   * @brief  SD Transfer Error callback.
1428   * @param  hsd: SD handle
1429   * @retval None
1430   */
1431 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
1432 {
1433   /* NOTE : This function Should not be modified, when the callback is needed,
1434             the HAL_SD_XferErrorCallback could be implemented in the user file
1435    */ 
1436 }
1437
1438 /**
1439   * @brief  SD Transfer complete Rx callback in non blocking mode.
1440   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1441   *                the configuration information for the specified DMA module.
1442   * @retval None
1443   */
1444 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
1445 {
1446   /* NOTE : This function Should not be modified, when the callback is needed,
1447             the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
1448    */ 
1449 }  
1450
1451 /**
1452   * @brief  SD DMA transfer complete Rx error callback.
1453   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1454   *                the configuration information for the specified DMA module.
1455   * @retval None
1456   */
1457 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
1458 {
1459   /* NOTE : This function Should not be modified, when the callback is needed,
1460             the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
1461    */ 
1462 }
1463
1464 /**
1465   * @brief  SD Transfer complete Tx callback in non blocking mode.
1466   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1467   *                the configuration information for the specified DMA module.
1468   * @retval None
1469   */
1470 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
1471 {
1472   /* NOTE : This function Should not be modified, when the callback is needed,
1473             the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
1474    */ 
1475 }  
1476
1477 /**
1478   * @brief  SD DMA transfer complete error Tx callback.
1479   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
1480   *                the configuration information for the specified DMA module.
1481   * @retval None
1482   */
1483 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
1484 {
1485   /* NOTE : This function Should not be modified, when the callback is needed,
1486             the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
1487    */ 
1488 }
1489
1490 /**
1491   * @}
1492   */
1493
1494 /** @addtogroup SD_Exported_Functions_Group3
1495  *  @brief   management functions 
1496  *
1497 @verbatim   
1498   ==============================================================================
1499                       ##### Peripheral Control functions #####
1500   ==============================================================================  
1501   [..]
1502     This subsection provides a set of functions allowing to control the SD card 
1503     operations.
1504
1505 @endverbatim
1506   * @{
1507   */
1508
1509 /**
1510   * @brief  Returns information about specific card.
1511   * @param  hsd: SD handle
1512   * @param  pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that  
1513   *         contains all SD cardinformation  
1514   * @retval SD Card error state
1515   */
1516 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
1517 {
1518   HAL_SD_ErrorTypedef errorstate = SD_OK;
1519   uint32_t tmp = 0;
1520   
1521   pCardInfo->CardType = (uint8_t)(hsd->CardType);
1522   pCardInfo->RCA      = (uint16_t)(hsd->RCA);
1523   
1524   /* Byte 0 */
1525   tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
1526   pCardInfo->SD_csd.CSDStruct      = (uint8_t)((tmp & 0xC0) >> 6);
1527   pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
1528   pCardInfo->SD_csd.Reserved1      = tmp & 0x03;
1529   
1530   /* Byte 1 */
1531   tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
1532   pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
1533   
1534   /* Byte 2 */
1535   tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
1536   pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
1537   
1538   /* Byte 3 */
1539   tmp = hsd->CSD[0] & 0x000000FF;
1540   pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
1541   
1542   /* Byte 4 */
1543   tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
1544   pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
1545   
1546   /* Byte 5 */
1547   tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
1548   pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
1549   pCardInfo->SD_csd.RdBlockLen       = (uint8_t)(tmp & 0x0F);
1550   
1551   /* Byte 6 */
1552   tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
1553   pCardInfo->SD_csd.PartBlockRead   = (uint8_t)((tmp & 0x80) >> 7);
1554   pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
1555   pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
1556   pCardInfo->SD_csd.DSRImpl         = (uint8_t)((tmp & 0x10) >> 4);
1557   pCardInfo->SD_csd.Reserved2       = 0; /*!< Reserved */
1558   
1559   if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
1560   {
1561     pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
1562     
1563     /* Byte 7 */
1564     tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1565     pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
1566     
1567     /* Byte 8 */
1568     tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1569     pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
1570     
1571     pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
1572     pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
1573     
1574     /* Byte 9 */
1575     tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1576     pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
1577     pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
1578     pCardInfo->SD_csd.DeviceSizeMul      = (tmp & 0x03) << 1;
1579     /* Byte 10 */
1580     tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1581     pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
1582     
1583     pCardInfo->CardCapacity  = (pCardInfo->SD_csd.DeviceSize + 1) ;
1584     pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
1585     pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
1586     pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
1587   }
1588   else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
1589   {
1590     /* Byte 7 */
1591     tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
1592     pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
1593     
1594     /* Byte 8 */
1595     tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
1596     
1597     pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
1598     
1599     /* Byte 9 */
1600     tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
1601     
1602     pCardInfo->SD_csd.DeviceSize |= (tmp);
1603     
1604     /* Byte 10 */
1605     tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
1606     
1607     pCardInfo->CardCapacity = (uint64_t)((((uint64_t)pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024);
1608     pCardInfo->CardBlockSize = 512;    
1609   }
1610   else
1611   {
1612     /* Not supported card type */
1613     errorstate = SD_ERROR;
1614   }
1615     
1616   pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
1617   pCardInfo->SD_csd.EraseGrMul  = (tmp & 0x3F) << 1;
1618   
1619   /* Byte 11 */
1620   tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
1621   pCardInfo->SD_csd.EraseGrMul     |= (tmp & 0x80) >> 7;
1622   pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
1623   
1624   /* Byte 12 */
1625   tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
1626   pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
1627   pCardInfo->SD_csd.ManDeflECC        = (tmp & 0x60) >> 5;
1628   pCardInfo->SD_csd.WrSpeedFact       = (tmp & 0x1C) >> 2;
1629   pCardInfo->SD_csd.MaxWrBlockLen     = (tmp & 0x03) << 2;
1630   
1631   /* Byte 13 */
1632   tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
1633   pCardInfo->SD_csd.MaxWrBlockLen      |= (tmp & 0xC0) >> 6;
1634   pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
1635   pCardInfo->SD_csd.Reserved3           = 0;
1636   pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
1637   
1638   /* Byte 14 */
1639   tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
1640   pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
1641   pCardInfo->SD_csd.CopyFlag         = (tmp & 0x40) >> 6;
1642   pCardInfo->SD_csd.PermWrProtect    = (tmp & 0x20) >> 5;
1643   pCardInfo->SD_csd.TempWrProtect    = (tmp & 0x10) >> 4;
1644   pCardInfo->SD_csd.FileFormat       = (tmp & 0x0C) >> 2;
1645   pCardInfo->SD_csd.ECC              = (tmp & 0x03);
1646   
1647   /* Byte 15 */
1648   tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
1649   pCardInfo->SD_csd.CSD_CRC   = (tmp & 0xFE) >> 1;
1650   pCardInfo->SD_csd.Reserved4 = 1;
1651   
1652   /* Byte 0 */
1653   tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
1654   pCardInfo->SD_cid.ManufacturerID = tmp;
1655   
1656   /* Byte 1 */
1657   tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
1658   pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
1659   
1660   /* Byte 2 */
1661   tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
1662   pCardInfo->SD_cid.OEM_AppliID |= tmp;
1663   
1664   /* Byte 3 */
1665   tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
1666   pCardInfo->SD_cid.ProdName1 = tmp << 24;
1667   
1668   /* Byte 4 */
1669   tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
1670   pCardInfo->SD_cid.ProdName1 |= tmp << 16;
1671   
1672   /* Byte 5 */
1673   tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
1674   pCardInfo->SD_cid.ProdName1 |= tmp << 8;
1675   
1676   /* Byte 6 */
1677   tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
1678   pCardInfo->SD_cid.ProdName1 |= tmp;
1679   
1680   /* Byte 7 */
1681   tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
1682   pCardInfo->SD_cid.ProdName2 = tmp;
1683   
1684   /* Byte 8 */
1685   tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
1686   pCardInfo->SD_cid.ProdRev = tmp;
1687   
1688   /* Byte 9 */
1689   tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
1690   pCardInfo->SD_cid.ProdSN = tmp << 24;
1691   
1692   /* Byte 10 */
1693   tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
1694   pCardInfo->SD_cid.ProdSN |= tmp << 16;
1695   
1696   /* Byte 11 */
1697   tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
1698   pCardInfo->SD_cid.ProdSN |= tmp << 8;
1699   
1700   /* Byte 12 */
1701   tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
1702   pCardInfo->SD_cid.ProdSN |= tmp;
1703   
1704   /* Byte 13 */
1705   tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
1706   pCardInfo->SD_cid.Reserved1   |= (tmp & 0xF0) >> 4;
1707   pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
1708   
1709   /* Byte 14 */
1710   tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
1711   pCardInfo->SD_cid.ManufactDate |= tmp;
1712   
1713   /* Byte 15 */
1714   tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
1715   pCardInfo->SD_cid.CID_CRC   = (tmp & 0xFE) >> 1;
1716   pCardInfo->SD_cid.Reserved2 = 1;
1717   
1718   return errorstate;
1719 }
1720
1721 /**
1722   * @brief  Enables wide bus operation for the requested card if supported by 
1723   *         card.
1724   * @param  hsd: SD handle       
1725   * @param  WideMode: Specifies the SD card wide bus mode 
1726   *          This parameter can be one of the following values:
1727   *            @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
1728   *            @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
1729   *            @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
1730   * @retval SD Card error state
1731   */
1732 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
1733 {
1734   HAL_SD_ErrorTypedef errorstate = SD_OK;
1735   SDIO_InitTypeDef tmpinit;
1736   
1737   /* MMC Card does not support this feature */
1738   if (hsd->CardType == MULTIMEDIA_CARD)
1739   {
1740     errorstate = SD_UNSUPPORTED_FEATURE;
1741     
1742     return errorstate;
1743   }
1744   else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
1745     (hsd->CardType == HIGH_CAPACITY_SD_CARD))
1746   {
1747     if (WideMode == SDIO_BUS_WIDE_8B)
1748     {
1749       errorstate = SD_UNSUPPORTED_FEATURE;
1750     }
1751     else if (WideMode == SDIO_BUS_WIDE_4B)
1752     {
1753       errorstate = SD_WideBus_Enable(hsd);
1754     }
1755     else if (WideMode == SDIO_BUS_WIDE_1B)
1756     {
1757       errorstate = SD_WideBus_Disable(hsd);
1758     }
1759     else
1760     {
1761       /* WideMode is not a valid argument*/
1762       errorstate = SD_INVALID_PARAMETER;
1763     }
1764       
1765     if (errorstate == SD_OK)
1766     {
1767       /* Configure the SDIO peripheral */
1768       tmpinit.ClockEdge           = hsd->Init.ClockEdge;
1769       tmpinit.ClockBypass         = hsd->Init.ClockBypass;
1770       tmpinit.ClockPowerSave      = hsd->Init.ClockPowerSave;
1771       tmpinit.BusWide             = WideMode;
1772       tmpinit.HardwareFlowControl = hsd->Init.HardwareFlowControl;
1773       tmpinit.ClockDiv            = hsd->Init.ClockDiv;
1774       SDIO_Init(hsd->Instance, tmpinit);
1775     }
1776   }
1777   
1778   return errorstate;
1779 }
1780
1781 /**
1782   * @brief  Aborts an ongoing data transfer.
1783   * @param  hsd: SD handle
1784   * @retval SD Card error state
1785   */
1786 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
1787 {
1788   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1789   HAL_SD_ErrorTypedef errorstate = SD_OK;
1790   
1791   /* Send CMD12 STOP_TRANSMISSION  */
1792   sdio_cmdinitstructure.Argument         = 0;
1793   sdio_cmdinitstructure.CmdIndex         = SD_CMD_STOP_TRANSMISSION;
1794   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1795   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1796   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1797   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1798   
1799   /* Check for error conditions */
1800   errorstate = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
1801   
1802   return errorstate;
1803 }
1804
1805 /**
1806   * @brief  Switches the SD card to High Speed mode.
1807   *         This API must be used after "Transfer State"
1808   * @note   This operation should be followed by the configuration 
1809   *         of PLL to have SDIOCK clock between 67 and 75 MHz
1810   * @param  hsd: SD handle
1811   * @retval SD Card error state
1812   */
1813 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
1814 {
1815   HAL_SD_ErrorTypedef errorstate = SD_OK;
1816   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
1817   SDIO_DataInitTypeDef sdio_datainitstructure;
1818   
1819   uint8_t SD_hs[64]  = {0};
1820   uint32_t SD_scr[2] = {0, 0};
1821   uint32_t SD_SPEC   = 0 ;
1822   uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
1823   
1824   /* Initialize the Data control register */
1825   hsd->Instance->DCTRL = 0;
1826   
1827   /* Get SCR Register */
1828   errorstate = SD_FindSCR(hsd, SD_scr);
1829   
1830   if (errorstate != SD_OK)
1831   {
1832     return errorstate;
1833   }
1834   
1835   /* Test the Version supported by the card*/ 
1836   SD_SPEC = (SD_scr[1]  & 0x01000000) | (SD_scr[1]  & 0x02000000);
1837   
1838   if (SD_SPEC != SD_ALLZERO)
1839   {
1840     /* Set Block Size for Card */
1841     sdio_cmdinitstructure.Argument         = (uint32_t)64;
1842     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
1843     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1844     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1845     sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1846     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1847     
1848     /* Check for error conditions */
1849     errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
1850     
1851     if (errorstate != SD_OK)
1852     {
1853       return errorstate;
1854     }
1855     
1856     /* Configure the SD DPSM (Data Path State Machine) */
1857     sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
1858     sdio_datainitstructure.DataLength    = 64;
1859     sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
1860     sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
1861     sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
1862     sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
1863     SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
1864     
1865     /* Send CMD6 switch mode */
1866     sdio_cmdinitstructure.Argument         = 0x80FFFF01;
1867     sdio_cmdinitstructure.CmdIndex         = SD_CMD_HS_SWITCH;
1868     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure); 
1869     
1870     /* Check for error conditions */
1871     errorstate = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
1872     
1873     if (errorstate != SD_OK)
1874     {
1875       return errorstate;
1876     }
1877
1878     while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
1879     {
1880       if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
1881       {
1882         for (count = 0; count < 8; count++)
1883         {
1884           *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
1885         }
1886         
1887         tempbuff += 8;
1888       }
1889     }
1890     
1891     if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
1892     {
1893       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
1894       
1895       errorstate = SD_DATA_TIMEOUT;
1896       
1897       return errorstate;
1898     }
1899     else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
1900     {
1901       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
1902       
1903       errorstate = SD_DATA_CRC_FAIL;
1904       
1905       return errorstate;
1906     }
1907     else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
1908     {
1909       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
1910       
1911       errorstate = SD_RX_OVERRUN;
1912       
1913       return errorstate;
1914     }
1915     else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
1916     {
1917       __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
1918       
1919       errorstate = SD_START_BIT_ERR;
1920       
1921       return errorstate;
1922     }
1923     else
1924     {
1925       /* No error flag set */
1926     }
1927     
1928     count = SD_DATATIMEOUT;
1929     
1930     while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
1931     {
1932       *tempbuff = SDIO_ReadFIFO(hsd->Instance);
1933       tempbuff++;
1934       count--;
1935     }
1936     
1937     /* Clear all the static flags */
1938     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1939     
1940     /* Test if the switch mode HS is ok */
1941     if ((SD_hs[13]& 2) != 2)
1942     {
1943       errorstate = SD_UNSUPPORTED_FEATURE;
1944     } 
1945   }
1946   
1947   return errorstate;
1948 }
1949
1950 /**
1951   * @}
1952   */
1953
1954 /** @addtogroup SD_Exported_Functions_Group4
1955  *  @brief   Peripheral State functions 
1956  *
1957 @verbatim   
1958   ==============================================================================
1959                       ##### Peripheral State functions #####
1960   ==============================================================================  
1961   [..]
1962     This subsection permits to get in runtime the status of the peripheral 
1963     and the data flow.
1964
1965 @endverbatim
1966   * @{
1967   */
1968
1969 /**
1970   * @brief  Returns the current SD card's status.
1971   * @param  hsd: SD handle
1972   * @param  pSDstatus: Pointer to the buffer that will contain the SD card status 
1973   *         SD Status register)
1974   * @retval SD Card error state
1975   */
1976 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
1977 {
1978   SDIO_CmdInitTypeDef  sdio_cmdinitstructure;
1979   SDIO_DataInitTypeDef sdio_datainitstructure;
1980   HAL_SD_ErrorTypedef errorstate = SD_OK;
1981   uint32_t count = 0;
1982   
1983   /* Check SD response */
1984   if ((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
1985   {
1986     errorstate = SD_LOCK_UNLOCK_FAILED;
1987     
1988     return errorstate;
1989   }
1990   
1991   /* Set block size for card if it is not equal to current block size for card */
1992   sdio_cmdinitstructure.Argument         = 64;
1993   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_BLOCKLEN;
1994   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
1995   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
1996   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
1997   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
1998   
1999   /* Check for error conditions */
2000   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
2001   
2002   if (errorstate != SD_OK)
2003   {
2004     return errorstate;
2005   }
2006   
2007   /* Send CMD55 */
2008   sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
2009   sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
2010   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2011   
2012   /* Check for error conditions */
2013   errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2014   
2015   if (errorstate != SD_OK)
2016   {
2017     return errorstate;
2018   }
2019   
2020   /* Configure the SD DPSM (Data Path State Machine) */ 
2021   sdio_datainitstructure.DataTimeOut   = SD_DATATIMEOUT;
2022   sdio_datainitstructure.DataLength    = 64;
2023   sdio_datainitstructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
2024   sdio_datainitstructure.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
2025   sdio_datainitstructure.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
2026   sdio_datainitstructure.DPSM          = SDIO_DPSM_ENABLE;
2027   SDIO_DataConfig(hsd->Instance, &sdio_datainitstructure);
2028   
2029   /* Send ACMD13 (SD_APP_STATUS)  with argument as card's RCA */
2030   sdio_cmdinitstructure.Argument         = 0;
2031   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_APP_STATUS;
2032   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2033   
2034   /* Check for error conditions */
2035   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STATUS);
2036   
2037   if (errorstate != SD_OK)
2038   {
2039     return errorstate;
2040   }
2041   
2042   /* Get status data */
2043   while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR))
2044   {
2045     if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2046     {
2047       for (count = 0; count < 8; count++)
2048       {
2049         *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
2050       }
2051       
2052       pSDstatus += 8;
2053     }
2054   }
2055   
2056   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
2057   {
2058     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
2059     
2060     errorstate = SD_DATA_TIMEOUT;
2061     
2062     return errorstate;
2063   }
2064   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2065   {
2066     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
2067     
2068     errorstate = SD_DATA_CRC_FAIL;
2069     
2070     return errorstate;
2071   }
2072   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2073   {
2074     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
2075     
2076     errorstate = SD_RX_OVERRUN;
2077     
2078     return errorstate;
2079   }
2080   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
2081   {
2082     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
2083     
2084     errorstate = SD_START_BIT_ERR;
2085     
2086     return errorstate;
2087   }
2088   else
2089   {
2090     /* No error flag set */
2091   }  
2092   
2093   count = SD_DATATIMEOUT;
2094   while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
2095   {
2096     *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
2097     pSDstatus++;
2098     count--;
2099   }
2100   
2101   /* Clear all the static status flags*/
2102   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2103   
2104   return errorstate;
2105 }
2106
2107 /**
2108   * @brief  Gets the current sd card data status.
2109   * @param  hsd: SD handle
2110   * @retval Data Transfer state
2111   */
2112 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
2113 {
2114   HAL_SD_CardStateTypedef cardstate =  SD_CARD_TRANSFER;
2115
2116   /* Get SD card state */
2117   cardstate = SD_GetState(hsd);
2118   
2119   /* Find SD status according to card state*/
2120   if (cardstate == SD_CARD_TRANSFER)
2121   {
2122     return SD_TRANSFER_OK;
2123   }
2124   else if(cardstate == SD_CARD_ERROR)
2125   {
2126     return SD_TRANSFER_ERROR;
2127   }
2128   else
2129   {
2130     return SD_TRANSFER_BUSY;
2131   }
2132 }
2133
2134 /**
2135   * @brief  Gets the SD card status.
2136   * @param  hsd: SD handle      
2137   * @param  pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that 
2138   *         will contain the SD card status information 
2139   * @retval SD Card error state
2140   */
2141 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
2142 {
2143   HAL_SD_ErrorTypedef errorstate = SD_OK;
2144   uint32_t tmp = 0;
2145   uint32_t sd_status[16];
2146   
2147   errorstate = HAL_SD_SendSDStatus(hsd, sd_status);
2148   
2149   if (errorstate  != SD_OK)
2150   {
2151     return errorstate;
2152   }
2153   
2154   /* Byte 0 */
2155   tmp = (sd_status[0] & 0xC0) >> 6;
2156   pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
2157   
2158   /* Byte 0 */
2159   tmp = (sd_status[0] & 0x20) >> 5;
2160   pCardStatus->SECURED_MODE = (uint8_t)tmp;
2161   
2162   /* Byte 2 */
2163   tmp = (sd_status[2] & 0xFF);
2164   pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
2165   
2166   /* Byte 3 */
2167   tmp = (sd_status[3] & 0xFF);
2168   pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
2169   
2170   /* Byte 4 */
2171   tmp = (sd_status[4] & 0xFF);
2172   pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
2173   
2174   /* Byte 5 */
2175   tmp = (sd_status[5] & 0xFF);
2176   pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
2177   
2178   /* Byte 6 */
2179   tmp = (sd_status[6] & 0xFF);
2180   pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
2181   
2182   /* Byte 7 */
2183   tmp = (sd_status[7] & 0xFF);
2184   pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
2185   
2186   /* Byte 8 */
2187   tmp = (sd_status[8] & 0xFF);
2188   pCardStatus->SPEED_CLASS = (uint8_t)tmp;
2189   
2190   /* Byte 9 */
2191   tmp = (sd_status[9] & 0xFF);
2192   pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
2193   
2194   /* Byte 10 */
2195   tmp = (sd_status[10] & 0xF0) >> 4;
2196   pCardStatus->AU_SIZE = (uint8_t)tmp;
2197   
2198   /* Byte 11 */
2199   tmp = (sd_status[11] & 0xFF);
2200   pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
2201   
2202   /* Byte 12 */
2203   tmp = (sd_status[12] & 0xFF);
2204   pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
2205   
2206   /* Byte 13 */
2207   tmp = (sd_status[13] & 0xFC) >> 2;
2208   pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
2209   
2210   /* Byte 13 */
2211   tmp = (sd_status[13] & 0x3);
2212   pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
2213   
2214   return errorstate;
2215 }
2216          
2217 /**
2218   * @}
2219   */
2220   
2221 /**
2222   * @}
2223   */
2224
2225 /* Private function ----------------------------------------------------------*/  
2226 /** @addtogroup SD_Private_Functions
2227   * @{
2228   */
2229   
2230 /**
2231   * @brief  SD DMA transfer complete Rx callback.
2232   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2233   *                the configuration information for the specified DMA module.
2234   * @retval None
2235   */
2236 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
2237 {
2238   SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2239   
2240   /* DMA transfer is complete */
2241   hsd->DmaTransferCplt = 1;
2242   
2243   /* Wait until SD transfer is complete */
2244   while(hsd->SdTransferCplt == 0)
2245   {
2246   }
2247   
2248   /* Disable the DMA channel */
2249   HAL_DMA_Abort(hdma);
2250
2251   /* Transfer complete user callback */
2252   HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);   
2253 }
2254
2255 /**
2256   * @brief  SD DMA transfer Error Rx callback.
2257   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2258   *                the configuration information for the specified DMA module.
2259   * @retval None
2260   */
2261 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
2262 {
2263   SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2264   
2265   /* Transfer complete user callback */
2266   HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
2267 }
2268
2269 /**
2270   * @brief  SD DMA transfer complete Tx callback.
2271   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2272   *                the configuration information for the specified DMA module.
2273   * @retval None
2274   */
2275 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
2276 {
2277   SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
2278   
2279   /* DMA transfer is complete */
2280   hsd->DmaTransferCplt = 1;
2281   
2282   /* Wait until SD transfer is complete */
2283   while(hsd->SdTransferCplt == 0)
2284   {
2285   }
2286  
2287   /* Disable the DMA channel */
2288   HAL_DMA_Abort(hdma);
2289
2290   /* Transfer complete user callback */
2291   HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);  
2292 }
2293
2294 /**
2295   * @brief  SD DMA transfer Error Tx callback.
2296   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
2297   *                the configuration information for the specified DMA module.
2298   * @retval None
2299   */
2300 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
2301 {
2302   SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
2303   
2304   /* Transfer complete user callback */
2305   HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
2306 }
2307
2308 /**
2309   * @brief  Returns the SD current state.
2310   * @param  hsd: SD handle
2311   * @retval SD card current state
2312   */
2313 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
2314 {
2315   uint32_t resp1 = 0;
2316   
2317   if (SD_SendStatus(hsd, &resp1) != SD_OK)
2318   {
2319     return SD_CARD_ERROR;
2320   }
2321   else
2322   {
2323     return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
2324   }
2325 }
2326
2327 /**
2328   * @brief  Initializes all cards or single card as the case may be Card(s) come 
2329   *         into standby state.
2330   * @param  hsd: SD handle
2331   * @retval SD Card error state
2332   */
2333 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
2334 {
2335   SDIO_CmdInitTypeDef sdio_cmdinitstructure; 
2336   HAL_SD_ErrorTypedef errorstate = SD_OK;
2337   uint16_t sd_rca = 1;
2338   
2339   if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
2340   {
2341     errorstate = SD_REQUEST_NOT_APPLICABLE;
2342     
2343     return errorstate;
2344   }
2345   
2346   if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
2347   {
2348     /* Send CMD2 ALL_SEND_CID */
2349     sdio_cmdinitstructure.Argument         = 0;
2350     sdio_cmdinitstructure.CmdIndex         = SD_CMD_ALL_SEND_CID;
2351     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_LONG;
2352     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2353     sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2354     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2355     
2356     /* Check for error conditions */
2357     errorstate = SD_CmdResp2Error(hsd);
2358     
2359     if(errorstate != SD_OK)
2360     {
2361       return errorstate;
2362     }
2363     
2364     /* Get Card identification number data */
2365     hsd->CID[0] = SDIO_GetResponse(SDIO_RESP1);
2366     hsd->CID[1] = SDIO_GetResponse(SDIO_RESP2);
2367     hsd->CID[2] = SDIO_GetResponse(SDIO_RESP3);
2368     hsd->CID[3] = SDIO_GetResponse(SDIO_RESP4);
2369   }
2370   
2371   if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1)    || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
2372      (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
2373   {
2374     /* Send CMD3 SET_REL_ADDR with argument 0 */
2375     /* SD Card publishes its RCA. */
2376     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SET_REL_ADDR;
2377     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2378     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2379     
2380     /* Check for error conditions */
2381     errorstate = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
2382     
2383     if(errorstate != SD_OK)
2384     {
2385       return errorstate;
2386     }
2387   }
2388   
2389   if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
2390   {
2391     /* Get the SD card RCA */
2392     hsd->RCA = sd_rca;
2393     
2394     /* Send CMD9 SEND_CSD with argument as card's RCA */
2395     sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
2396     sdio_cmdinitstructure.CmdIndex         = SD_CMD_SEND_CSD;
2397     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_LONG;
2398     SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2399     
2400     /* Check for error conditions */
2401     errorstate = SD_CmdResp2Error(hsd);
2402     
2403     if(errorstate != SD_OK)
2404     {
2405       return errorstate;
2406     }
2407     
2408     /* Get Card Specific Data */
2409     hsd->CSD[0] = SDIO_GetResponse(SDIO_RESP1);
2410     hsd->CSD[1] = SDIO_GetResponse(SDIO_RESP2);
2411     hsd->CSD[2] = SDIO_GetResponse(SDIO_RESP3);
2412     hsd->CSD[3] = SDIO_GetResponse(SDIO_RESP4);
2413   }
2414   
2415   /* All cards are initialized */
2416   return errorstate;
2417 }
2418
2419 /**
2420   * @brief  Selects of Deselects the corresponding card.
2421   * @param  hsd: SD handle
2422   * @param  addr: Address of the card to be selected  
2423   * @retval SD Card error state
2424   */
2425 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
2426 {
2427   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2428   HAL_SD_ErrorTypedef errorstate = SD_OK;
2429   
2430   /* Send CMD7 SDIO_SEL_DESEL_CARD */
2431   sdio_cmdinitstructure.Argument         = (uint32_t)addr;
2432   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SEL_DESEL_CARD;
2433   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2434   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2435   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2436   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2437   
2438   /* Check for error conditions */
2439   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
2440   
2441   return errorstate;
2442 }
2443
2444 /**
2445   * @brief  Enquires cards about their operating voltage and configures clock
2446   *         controls and stores SD information that will be needed in future
2447   *         in the SD handle.
2448   * @param  hsd: SD handle
2449   * @retval SD Card error state
2450   */
2451 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
2452 {
2453   SDIO_CmdInitTypeDef sdio_cmdinitstructure; 
2454   __IO HAL_SD_ErrorTypedef errorstate = SD_OK; 
2455   uint32_t response = 0, count = 0, validvoltage = 0;
2456   uint32_t sdtype = SD_STD_CAPACITY;
2457   
2458   /* Power ON Sequence -------------------------------------------------------*/
2459   /* Disable SDIO Clock */
2460   __HAL_SD_SDIO_DISABLE(); 
2461   
2462   /* Set Power State to ON */
2463   SDIO_PowerState_ON(hsd->Instance);
2464   
2465   /* 1ms: required power up waiting time before starting the SD initialization 
2466      sequence */
2467   HAL_Delay(1);
2468   
2469   /* Enable SDIO Clock */
2470   __HAL_SD_SDIO_ENABLE();
2471   
2472   /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
2473   /* No CMD response required */
2474   sdio_cmdinitstructure.Argument         = 0;
2475   sdio_cmdinitstructure.CmdIndex         = SD_CMD_GO_IDLE_STATE;
2476   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_NO;
2477   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2478   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2479   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2480   
2481   /* Check for error conditions */
2482   errorstate = SD_CmdError(hsd);
2483   
2484   if(errorstate != SD_OK)
2485   {
2486     /* CMD Response Timeout (wait for CMDSENT flag) */
2487     return errorstate;
2488   }
2489   
2490   /* CMD8: SEND_IF_COND ------------------------------------------------------*/
2491   /* Send CMD8 to verify SD card interface operating condition */
2492   /* Argument: - [31:12]: Reserved (shall be set to '0')
2493   - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
2494   - [7:0]: Check Pattern (recommended 0xAA) */
2495   /* CMD Response: R7 */
2496   sdio_cmdinitstructure.Argument         = SD_CHECK_PATTERN;
2497   sdio_cmdinitstructure.CmdIndex         = SD_SDIO_SEND_IF_COND;
2498   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2499   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2500   
2501   /* Check for error conditions */ 
2502   errorstate = SD_CmdResp7Error(hsd);
2503   
2504   if (errorstate == SD_OK)
2505   {
2506     /* SD Card 2.0 */
2507     hsd->CardType = STD_CAPACITY_SD_CARD_V2_0; 
2508     sdtype        = SD_HIGH_CAPACITY;
2509   }
2510   
2511   /* Send CMD55 */
2512   sdio_cmdinitstructure.Argument         = 0;
2513   sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
2514   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2515   
2516   /* Check for error conditions */
2517   errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2518   
2519   /* If errorstate is Command Timeout, it is a MMC card */
2520   /* If errorstate is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
2521      or SD card 1.x */
2522   if(errorstate == SD_OK)
2523   {
2524     /* SD CARD */
2525     /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2526     while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
2527     {
2528       
2529       /* SEND CMD55 APP_CMD with RCA as 0 */
2530       sdio_cmdinitstructure.Argument         = 0;
2531       sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
2532       sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2533       sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2534       sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2535       SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2536       
2537       /* Check for error conditions */
2538       errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
2539       
2540       if(errorstate != SD_OK)
2541       {
2542         return errorstate;
2543       }
2544       
2545       /* Send CMD41 */
2546       sdio_cmdinitstructure.Argument         = SD_VOLTAGE_WINDOW_SD | sdtype;
2547       sdio_cmdinitstructure.CmdIndex         = SD_CMD_SD_APP_OP_COND;
2548       sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2549       sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2550       sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2551       SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2552       
2553       /* Check for error conditions */
2554       errorstate = SD_CmdResp3Error(hsd);
2555       
2556       if(errorstate != SD_OK)
2557       {
2558         return errorstate;
2559       }
2560       
2561       /* Get command response */
2562       response = SDIO_GetResponse(SDIO_RESP1);
2563       
2564       /* Get operating voltage*/
2565       validvoltage = (((response >> 31) == 1) ? 1 : 0);
2566       
2567       count++;
2568     }
2569     
2570     if(count >= SD_MAX_VOLT_TRIAL)
2571     {
2572       errorstate = SD_INVALID_VOLTRANGE;
2573       
2574       return errorstate;
2575     }
2576     
2577     if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2578     {
2579       hsd->CardType = HIGH_CAPACITY_SD_CARD;
2580     }
2581     
2582   } /* else MMC Card */
2583   
2584   return errorstate;
2585 }
2586
2587 /**
2588   * @brief  Turns the SDIO output signals off.
2589   * @param  hsd: SD handle
2590   * @retval SD Card error state
2591   */
2592 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
2593 {
2594   HAL_SD_ErrorTypedef errorstate = SD_OK;
2595   
2596   /* Set Power State to OFF */
2597   SDIO_PowerState_OFF(hsd->Instance);
2598   
2599   return errorstate;
2600 }
2601
2602 /**
2603   * @brief  Returns the current card's status.
2604   * @param  hsd: SD handle
2605   * @param  pCardStatus: pointer to the buffer that will contain the SD card 
2606   *         status (Card Status register)  
2607   * @retval SD Card error state
2608   */
2609 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
2610 {
2611   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
2612   HAL_SD_ErrorTypedef errorstate = SD_OK;
2613   
2614   if(pCardStatus == NULL)
2615   {
2616     errorstate = SD_INVALID_PARAMETER;
2617     
2618     return errorstate;
2619   }
2620   
2621   /* Send Status command */
2622   sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
2623   sdio_cmdinitstructure.CmdIndex         = SD_CMD_SEND_STATUS;
2624   sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
2625   sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
2626   sdio_cmdinitstructure.CPSM             = SDIO_CPSM_ENABLE;
2627   SDIO_SendCommand(hsd->Instance, &sdio_cmdinitstructure);
2628   
2629   /* Check for error conditions */
2630   errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
2631   
2632   if(errorstate != SD_OK)
2633   {
2634     return errorstate;
2635   }
2636   
2637   /* Get SD card status */
2638   *pCardStatus = SDIO_GetResponse(SDIO_RESP1);
2639   
2640   return errorstate;
2641 }
2642
2643 /**
2644   * @brief  Checks for error conditions for CMD0.
2645   * @param  hsd: SD handle
2646   * @retval SD Card error state
2647   */
2648 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
2649 {
2650   HAL_SD_ErrorTypedef errorstate = SD_OK;
2651   uint32_t timeout, tmp;
2652   
2653   timeout = SDIO_CMD0TIMEOUT;
2654   
2655   tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2656     
2657   while((timeout > 0) && (!tmp))
2658   {
2659     tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
2660     timeout--;
2661   }
2662   
2663   if(timeout == 0)
2664   {
2665     errorstate = SD_CMD_RSP_TIMEOUT;
2666     return errorstate;
2667   }
2668   
2669   /* Clear all the static flags */
2670   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2671   
2672   return errorstate;
2673 }
2674
2675 /**
2676   * @brief  Checks for error conditions for R7 response.
2677   * @param  hsd: SD handle
2678   * @retval SD Card error state
2679   */
2680 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
2681 {
2682   HAL_SD_ErrorTypedef errorstate = SD_ERROR;
2683   uint32_t timeout = SDIO_CMD0TIMEOUT, tmp;
2684   
2685   tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT); 
2686   
2687   while((!tmp) && (timeout > 0))
2688   {
2689     tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
2690     timeout--;
2691   }
2692   
2693   tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT); 
2694   
2695   if((timeout == 0) || tmp)
2696   {
2697     /* Card is not V2.0 compliant or card does not support the set voltage range */
2698     errorstate = SD_CMD_RSP_TIMEOUT;
2699     
2700     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2701     
2702     return errorstate;
2703   }
2704   
2705   if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
2706   {
2707     /* Card is SD V2.0 compliant */
2708     errorstate = SD_OK;
2709     
2710     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
2711     
2712     return errorstate;
2713   }
2714   
2715   return errorstate;
2716 }
2717
2718 /**
2719   * @brief  Checks for error conditions for R1 response.
2720   * @param  hsd: SD handle
2721   * @param  SD_CMD: The sent command index  
2722   * @retval SD Card error state
2723   */
2724 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
2725 {
2726   HAL_SD_ErrorTypedef errorstate = SD_OK;
2727   uint32_t response_r1;
2728   
2729   while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2730   {
2731   }
2732   
2733   if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2734   {
2735     errorstate = SD_CMD_RSP_TIMEOUT;
2736     
2737     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2738     
2739     return errorstate;
2740   }
2741   else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2742   {
2743     errorstate = SD_CMD_CRC_FAIL;
2744     
2745     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2746     
2747     return errorstate;
2748   }
2749   
2750   /* Check response received is of desired command */
2751   if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2752   {
2753     errorstate = SD_ILLEGAL_CMD;
2754     
2755     return errorstate;
2756   }
2757   
2758   /* Clear all the static flags */
2759   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2760   
2761   /* We have received response, retrieve it for analysis  */
2762   response_r1 = SDIO_GetResponse(SDIO_RESP1);
2763   
2764   if((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
2765   {
2766     return errorstate;
2767   }
2768   
2769   if((response_r1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
2770   {
2771     return(SD_ADDR_OUT_OF_RANGE);
2772   }
2773   
2774   if((response_r1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
2775   {
2776     return(SD_ADDR_MISALIGNED);
2777   }
2778   
2779   if((response_r1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
2780   {
2781     return(SD_BLOCK_LEN_ERR);
2782   }
2783   
2784   if((response_r1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
2785   {
2786     return(SD_ERASE_SEQ_ERR);
2787   }
2788   
2789   if((response_r1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
2790   {
2791     return(SD_BAD_ERASE_PARAM);
2792   }
2793   
2794   if((response_r1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
2795   {
2796     return(SD_WRITE_PROT_VIOLATION);
2797   }
2798   
2799   if((response_r1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
2800   {
2801     return(SD_LOCK_UNLOCK_FAILED);
2802   }
2803   
2804   if((response_r1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
2805   {
2806     return(SD_COM_CRC_FAILED);
2807   }
2808   
2809   if((response_r1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
2810   {
2811     return(SD_ILLEGAL_CMD);
2812   }
2813   
2814   if((response_r1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
2815   {
2816     return(SD_CARD_ECC_FAILED);
2817   }
2818   
2819   if((response_r1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
2820   {
2821     return(SD_CC_ERROR);
2822   }
2823   
2824   if((response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
2825   {
2826     return(SD_GENERAL_UNKNOWN_ERROR);
2827   }
2828   
2829   if((response_r1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
2830   {
2831     return(SD_STREAM_READ_UNDERRUN);
2832   }
2833   
2834   if((response_r1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
2835   {
2836     return(SD_STREAM_WRITE_OVERRUN);
2837   }
2838   
2839   if((response_r1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
2840   {
2841     return(SD_CID_CSD_OVERWRITE);
2842   }
2843   
2844   if((response_r1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
2845   {
2846     return(SD_WP_ERASE_SKIP);
2847   }
2848   
2849   if((response_r1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
2850   {
2851     return(SD_CARD_ECC_DISABLED);
2852   }
2853   
2854   if((response_r1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
2855   {
2856     return(SD_ERASE_RESET);
2857   }
2858   
2859   if((response_r1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
2860   {
2861     return(SD_AKE_SEQ_ERROR);
2862   }
2863   
2864   return errorstate;
2865 }
2866
2867 /**
2868   * @brief  Checks for error conditions for R3 (OCR) response.
2869   * @param  hsd: SD handle
2870   * @retval SD Card error state
2871   */
2872 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
2873 {
2874   HAL_SD_ErrorTypedef errorstate = SD_OK;
2875   
2876   while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2877   {
2878   }
2879   
2880   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2881   {
2882     errorstate = SD_CMD_RSP_TIMEOUT;
2883     
2884     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2885     
2886     return errorstate;
2887   }
2888   
2889   /* Clear all the static flags */
2890   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2891   
2892   return errorstate;
2893 }
2894
2895 /**
2896   * @brief  Checks for error conditions for R2 (CID or CSD) response.
2897   * @param  hsd: SD handle
2898   * @retval SD Card error state
2899   */
2900 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
2901 {
2902   HAL_SD_ErrorTypedef errorstate = SD_OK;
2903   
2904   while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2905   {
2906   }
2907     
2908   if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2909   {
2910     errorstate = SD_CMD_RSP_TIMEOUT;
2911     
2912     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2913     
2914     return errorstate;
2915   }
2916   else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2917   {
2918     errorstate = SD_CMD_CRC_FAIL;
2919     
2920     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2921     
2922     return errorstate;
2923   }
2924   else
2925   {
2926     /* No error flag set */
2927   }
2928   
2929   /* Clear all the static flags */
2930   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2931   
2932   return errorstate;
2933 }
2934
2935 /**
2936   * @brief  Checks for error conditions for R6 (RCA) response.
2937   * @param  hsd: SD handle
2938   * @param  SD_CMD: The sent command index
2939   * @param  pRCA: Pointer to the variable that will contain the SD card relative 
2940   *         address RCA   
2941   * @retval SD Card error state
2942   */
2943 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
2944 {
2945   HAL_SD_ErrorTypedef errorstate = SD_OK;
2946   uint32_t response_r1;
2947   
2948   while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
2949   {
2950   }
2951   
2952   if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
2953   {
2954     errorstate = SD_CMD_RSP_TIMEOUT;
2955     
2956     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
2957     
2958     return errorstate;
2959   }
2960   else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
2961   {
2962     errorstate = SD_CMD_CRC_FAIL;
2963     
2964     __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
2965     
2966     return errorstate;
2967   }
2968   else
2969   {
2970     /* No error flag set */
2971   }
2972   
2973   /* Check response received is of desired command */
2974   if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
2975   {
2976     errorstate = SD_ILLEGAL_CMD;
2977     
2978     return errorstate;
2979   }
2980   
2981   /* Clear all the static flags */
2982   __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2983   
2984   /* We have received response, retrieve it.  */
2985   response_r1 = SDIO_GetResponse(SDIO_RESP1);
2986   
2987   if((response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
2988   {
2989     *pRCA = (uint16_t) (response_r1 >> 16);
2990     
2991     return errorstate;
2992   }
2993   
2994   if((response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
2995   {
2996     return(SD_GENERAL_UNKNOWN_ERROR);
2997   }
2998   
2999   if((response_r1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
3000   {
3001     return(SD_ILLEGAL_CMD);
3002   }
3003   
3004   if((response_r1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
3005   {
3006     return(SD_COM_CRC_FAILED);
3007   }
3008   
3009   return errorstate;
3010 }
3011
3012 /**
3013   * @brief  Enables the SDIO wide bus mode.
3014   * @param  hsd: SD handle
3015   * @retval SD Card error state
3016   */
3017 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
3018 {
3019   SDIO_CmdInitTypeDef sdio_cmdinitstructure;
3020   HAL_SD_ErrorTypedef errorstate = SD_OK;
3021   
3022   uint32_t scr[2] = {0, 0};
3023   
3024   if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
3025   {
3026     errorstate = SD_LOCK_UNLOCK_FAILED;
3027     
3028     return errorstate;
3029   }
3030   
3031   /* Get SCR Register */
3032   errorstate = SD_FindSCR(hsd, scr);
3033   
3034   if(errorstate != SD_OK)
3035   {
3036     return errorstate;
3037   }
3038   
3039   /* If requested card supports wide bus operation */
3040   if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
3041   {
3042     /* Send CMD55 APP_CMD with argument as card's RCA.*/
3043     sdio_cmdinitstructure.Argument         = (uint32_t)(hsd->RCA << 16);
3044     sdio_cmdinitstructure.CmdIndex         = SD_CMD_APP_CMD;
3045     sdio_cmdinitstructure.Response         = SDIO_RESPONSE_SHORT;
3046     sdio_cmdinitstructure.WaitForInterrupt = SDIO_WAIT_NO;
3047     sdio_cmdinitstructure.CPSM    &n