mbed-dev - inport from local

Users » NYX » Code » mbed-dev

inport from local

targets/TARGET_STM/TARGET_STM32F4/device/stm32f4xx_hal_sd.c@0:85b3fd62ea1a, 2020-03-16 (annotated)

Committer:: NYX
Date:: Mon Mar 16 06:35:48 2020 +0000
Revision:: 0:85b3fd62ea1a

reinport to mbed;

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	16 Mar 2020
Imports:	73
Forks:	0
Commits:	1
Dependents:	1
Dependencies:	0
Followers:	2

targets/TARGET_STM/TARGET_STM32F4/device/stm32f4xx_hal_sd.c@0:85b3fd62ea1a, 2020-03-16 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning