mbed-src - Lancaster University's (short term!) clone of mbe…

Lancaster University » Code » mbed-src

Lancaster University's (short term!) clone of mbed-src for micro:bit. This is a copy of the github branch https://github.com/lancaster-university/mbed-classic

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_sd.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:: mbed_official
Date:: Fri Aug 14 13:15:17 2015 +0100
Revision:: 610:813dcc80987e
Parent:: 573:ad23fe03a082

Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599

Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/

DISCO_F746NG - Improvements

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	06 Apr 2016
Imports:	21
Forks:	0
Commits:	642
Dependents:	0
Dependencies:	0
Followers:	14

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_sd.c@610:813dcc80987e, 2015-08-14 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning