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