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