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

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

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

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

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

mbed library release version 165

Who changed what in which revision?

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