mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F1/device/stm32f1xx_hal_sd.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:: AnnaBridge
Date:: Wed Feb 20 22:31:08 2019 +0000
Revision:: 189:f392fc9709a3
Parent:: 187:0387e8f68319

mbed library release version 165

Who changed what in which revision?

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