517 lines
15 KiB
C
517 lines
15 KiB
C
/**
|
||
******************************************************************************
|
||
* @file stm32h743i_eval_sd.c
|
||
* @author MCD Application Team
|
||
* @version V1.2.0
|
||
* @date 29-December-2017
|
||
* @brief This file includes the uSD card driver mounted on STM32H743I-EVAL
|
||
* evaluation boards.
|
||
@verbatim
|
||
How To use this driver:
|
||
-----------------------
|
||
- This driver is used to drive the micro SD external cards mounted on STM32H743I-EVAL
|
||
evaluation board.
|
||
- This driver does not need a specific component driver for the micro SD device
|
||
to be included with.
|
||
|
||
Driver description:
|
||
------------------
|
||
+ Initialization steps:
|
||
o Initialize the micro SD card using the BSP_SD_Init() function. This
|
||
function includes the MSP layer hardware resources initialization and the
|
||
SDIO interface configuration to interface with the external micro SD. It
|
||
also includes the micro SD initialization sequence for SDCard1.
|
||
o To check the SD card presence you can use the function BSP_SD_IsDetected() which
|
||
returns the detection status for SDCard1. The function BSP_SD_IsDetected() returns
|
||
the detection status for SDCard1.
|
||
o If SD presence detection interrupt mode is desired, you must configure the
|
||
SD detection interrupt mode by calling the functions BSP_SD_ITConfig() for
|
||
SDCard1. The interrupt is generated as an external interrupt whenever the
|
||
micro SD card is plugged/unplugged in/from the evaluation board. The SD detection
|
||
is managed by MFX, so the SD detection interrupt has to be treated by MFX_IRQOUT
|
||
gpio pin IRQ handler.
|
||
o The function BSP_SD_GetCardInfo() are used to get the micro SD card information
|
||
which is stored in the structure "HAL_SD_CardInfoTypedef".
|
||
|
||
+ Micro SD card operations
|
||
o The micro SD card can be accessed with read/write block(s) operations once
|
||
it is ready for access. The access, by default to SDCard1, can be performed whether
|
||
using the polling mode by calling the functions BSP_SD_ReadBlocks()/BSP_SD_WriteBlocks(),
|
||
or by DMA transfer using the functions BSP_SD_ReadBlocks_DMA()/BSP_SD_WriteBlocks_DMA().
|
||
o The DMA transfer complete is used with interrupt mode. Once the SD transfer
|
||
is complete, the SD interrupt is handled using the function BSP_SDMMC1_IRQHandler()
|
||
when SDCard1 is used.
|
||
o The SD erase block(s) is performed using the functions BSP_SD_Erase() with specifying
|
||
the number of blocks to erase.
|
||
o The SD runtime status is returned when calling the function BSP_SD_GetStatus().
|
||
|
||
@endverbatim
|
||
******************************************************************************
|
||
* @attention
|
||
*
|
||
* <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without modification,
|
||
* are permitted provided that the following conditions are met:
|
||
* 1. Redistributions of source code must retain the above copyright notice,
|
||
* this list of conditions and the following disclaimer.
|
||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||
* this list of conditions and the following disclaimer in the documentation
|
||
* and/or other materials provided with the distribution.
|
||
* 3. Neither the name of STMicroelectronics nor the names of its contributors
|
||
* may be used to endorse or promote products derived from this software
|
||
* without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
*
|
||
******************************************************************************
|
||
*/
|
||
|
||
/* Includes ------------------------------------------------------------------*/
|
||
#include "stm32h7xx_hal.h"
|
||
#include "sdio.h"
|
||
|
||
//#define SD_DETECT_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
|
||
|
||
//#define SD_DETECT_GPIO_PORT GPIOG
|
||
//#define SD_DETECT_PIN GPIO_PIN_9
|
||
|
||
//#define SD_IS_INSERTED() ((SD_DETECT_GPIO_PORT->IDR & SD_DETECT_PIN) == 0)
|
||
|
||
#define SD_IS_INSERTED() 1
|
||
|
||
SD_HandleTypeDef uSdHandle;
|
||
//static uint8_t UseExtiModeDetection = 0;
|
||
|
||
/**
|
||
* @brief Initializes the SD card device.
|
||
* @retval SD status
|
||
*/
|
||
uint8_t BSP_SD_Init(void)
|
||
{
|
||
uint8_t sd_state = MSD_OK;
|
||
|
||
/* uSD device interface configuration */
|
||
uSdHandle.Instance = SDMMC1;
|
||
|
||
uSdHandle.Init.ClockDiv = 2; /* <20><><EFBFBD>ٿ<EFBFBD><D9BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD><EFBFBD>ٿ<EFBFBD><D9BF><EFBFBD>2<EFBFBD><32><EFBFBD><EFBFBD>1<EFBFBD><31><EFBFBD>ȶ<EFBFBD><C8B6><EFBFBD> */
|
||
uSdHandle.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
|
||
uSdHandle.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
|
||
uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
|
||
uSdHandle.Init.BusWide = SDMMC_BUS_WIDE_4B;
|
||
|
||
/* Check if the SD card is plugged in the slot */
|
||
#ifdef SD_DETECT_GPIO_PORT
|
||
{
|
||
GPIO_InitTypeDef gpio_init;
|
||
|
||
SD_DETECT_GPIO_CLK_ENABLE(); /* <20><><EFBFBD><EFBFBD>GPIOʱ<4F><CAB1> */
|
||
|
||
gpio_init.Mode = GPIO_MODE_INPUT; /* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
|
||
gpio_init.Pull = GPIO_NOPULL; /* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>費ʹ<E8B2BB><CAB9> */
|
||
gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH; /* GPIO<49>ٶȵȼ<C8B5> */
|
||
gpio_init.Pin = SD_DETECT_PIN;
|
||
HAL_GPIO_Init(SD_DETECT_GPIO_PORT, &gpio_init);
|
||
}
|
||
#endif
|
||
|
||
#if 0
|
||
/* Initialise Transciver MFXPIN to enable 1.8V Switch mode */
|
||
BSP_IO_ConfigPin(SD_LDO_SEL_PIN, IO_MODE_OUTPUT_PP_PU);
|
||
#endif
|
||
|
||
if (BSP_SD_IsDetected() != SD_PRESENT)
|
||
{
|
||
return MSD_ERROR_SD_NOT_PRESENT;
|
||
}
|
||
|
||
/* Msp SD initialization */
|
||
BSP_SD_MspInit(&uSdHandle, NULL);
|
||
|
||
/* HAL SD initialization */
|
||
if (HAL_SD_Init(&uSdHandle) != HAL_OK)
|
||
{
|
||
sd_state = MSD_ERROR;
|
||
}
|
||
|
||
return sd_state;
|
||
}
|
||
|
||
/**
|
||
* @brief DeInitializes the SD card device.
|
||
* @retval SD status
|
||
*/
|
||
uint8_t BSP_SD_DeInit(void)
|
||
{
|
||
uint8_t sd_state = MSD_OK;
|
||
|
||
uSdHandle.Instance = SDMMC1;
|
||
|
||
/* Set back Mfx pin to INPUT mode in case it was in exti */
|
||
//UseExtiModeDetection = 0;
|
||
|
||
/* HAL SD deinitialization */
|
||
if (HAL_SD_DeInit(&uSdHandle) != HAL_OK)
|
||
{
|
||
sd_state = MSD_ERROR;
|
||
}
|
||
|
||
/* Msp SD deinitialization */
|
||
uSdHandle.Instance = SDMMC1;
|
||
BSP_SD_MspDeInit(&uSdHandle, NULL);
|
||
|
||
return sd_state;
|
||
}
|
||
|
||
/**
|
||
* @brief Configures Interrupt mode for SD1 detection pin.
|
||
* @retval Returns 0
|
||
*/
|
||
uint8_t BSP_SD_ITConfig(void)
|
||
{
|
||
#if 0 /* <20><>ʹ<EFBFBD><CAB9><EFBFBD>ⲿEXIT<49>жϼ<D0B6><CFBC><EFBFBD> */
|
||
/* Configure Interrupt mode for SD detection pin */
|
||
/* Note: disabling exti mode can be done calling BSP_SD_DeInit() */
|
||
UseExtiModeDetection = 1;
|
||
BSP_SD_IsDetected();
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief Detects if SD card is correctly plugged in the memory slot or not.
|
||
* @retval Returns if SD is detected or not
|
||
*/
|
||
uint8_t BSP_SD_IsDetected(void)
|
||
{
|
||
__IO uint8_t status = SD_PRESENT;
|
||
|
||
/* Check SD card detect pin */
|
||
if (SD_IS_INSERTED())
|
||
{
|
||
status = SD_PRESENT;
|
||
}
|
||
else
|
||
{
|
||
status = SD_NOT_PRESENT;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
/**
|
||
* @brief Reads block(s) from a specified address in an SD card, in polling mode.
|
||
* @param pData: Pointer to the buffer that will contain the data to transmit
|
||
* @param ReadAddr: Address from where data is to be read
|
||
* @param NumOfBlocks: Number of SD blocks to read
|
||
* @param Timeout: Timeout for read operation
|
||
* @retval SD status
|
||
*/
|
||
uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)
|
||
{
|
||
|
||
if (HAL_SD_ReadBlocks(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) == HAL_OK)
|
||
{
|
||
return MSD_OK;
|
||
}
|
||
else
|
||
{
|
||
return MSD_ERROR;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Writes block(s) to a specified address in an SD card, in polling mode.
|
||
* @param pData: Pointer to the buffer that will contain the data to transmit
|
||
* @param WriteAddr: Address from where data is to be written
|
||
* @param NumOfBlocks: Number of SD blocks to write
|
||
* @param Timeout: Timeout for write operation
|
||
* @retval SD status
|
||
*/
|
||
uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)
|
||
{
|
||
|
||
if (HAL_SD_WriteBlocks(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) == HAL_OK)
|
||
{
|
||
return MSD_OK;
|
||
}
|
||
else
|
||
{
|
||
return MSD_ERROR;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Reads block(s) from a specified address in an SD card, in DMA mode.
|
||
* @param pData: Pointer to the buffer that will contain the data to transmit
|
||
* @param ReadAddr: Address from where data is to be read
|
||
* @param NumOfBlocks: Number of SD blocks to read
|
||
* @retval SD status
|
||
*/
|
||
uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks)
|
||
{
|
||
|
||
if (HAL_SD_ReadBlocks_DMA(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks) == HAL_OK)
|
||
{
|
||
return MSD_OK;
|
||
}
|
||
else
|
||
{
|
||
return MSD_ERROR;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Writes block(s) to a specified address in an SD card, in DMA mode.
|
||
* @param pData: Pointer to the buffer that will contain the data to transmit
|
||
* @param WriteAddr: Address from where data is to be written
|
||
* @param NumOfBlocks: Number of SD blocks to write
|
||
* @retval SD status
|
||
*/
|
||
uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
|
||
{
|
||
|
||
if (HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)
|
||
{
|
||
return MSD_OK;
|
||
}
|
||
else
|
||
{
|
||
return MSD_ERROR;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Erases the specified memory area of the given SD card.
|
||
* @param StartAddr: Start byte address
|
||
* @param EndAddr: End byte address
|
||
* @retval SD status
|
||
*/
|
||
uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)
|
||
{
|
||
|
||
if (HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) == HAL_OK)
|
||
{
|
||
return MSD_OK;
|
||
}
|
||
else
|
||
{
|
||
return MSD_ERROR;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Initializes the SD MSP.
|
||
* @param hsd: SD handle
|
||
* @param Params: Pointer to void
|
||
* @retval None
|
||
*/
|
||
__weak void BSP_SD_MspInit(SD_HandleTypeDef *hsd, void *Params)
|
||
{
|
||
|
||
GPIO_InitTypeDef gpio_init_structure;
|
||
|
||
/* Enable SDIO clock */
|
||
__HAL_RCC_SDMMC1_CLK_ENABLE();
|
||
|
||
/* Enable GPIOs clock */
|
||
__HAL_RCC_GPIOB_CLK_ENABLE();
|
||
__HAL_RCC_GPIOC_CLK_ENABLE();
|
||
__HAL_RCC_GPIOD_CLK_ENABLE();
|
||
|
||
gpio_init_structure.Mode = GPIO_MODE_AF_PP;
|
||
gpio_init_structure.Pull = GPIO_NOPULL;
|
||
gpio_init_structure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //GPIO_SPEED_FREQ_VERY_HIGH;
|
||
|
||
/* D0(PC8), D1(PC9), D2(PC10), D3(PC11), CK(PC12), CMD(PD2) */
|
||
/* Common GPIO configuration */
|
||
gpio_init_structure.Alternate = GPIO_AF12_SDIO1;
|
||
|
||
/* GPIOC configuration */
|
||
gpio_init_structure.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12;
|
||
HAL_GPIO_Init(GPIOC, &gpio_init_structure);
|
||
|
||
/* GPIOD configuration */
|
||
gpio_init_structure.Pin = GPIO_PIN_2;
|
||
HAL_GPIO_Init(GPIOD, &gpio_init_structure);
|
||
|
||
// /* D0DIR(PC6), D123DIR(PC7) */
|
||
// gpio_init_structure.Alternate = GPIO_AF8_SDIO1;
|
||
// /* GPIOC configuration */
|
||
// gpio_init_structure.Pin = GPIO_PIN_6 | GPIO_PIN_7;
|
||
// HAL_GPIO_Init(GPIOC, &gpio_init_structure);
|
||
|
||
// /* CKIN(PB8), CDIR(PB9) */
|
||
// gpio_init_structure.Alternate = GPIO_AF7_SDIO1;
|
||
// /* GPIOB configuration */
|
||
// gpio_init_structure.Pin = GPIO_PIN_8 | GPIO_PIN_9;
|
||
// HAL_GPIO_Init(GPIOB, &gpio_init_structure);
|
||
|
||
__HAL_RCC_SDMMC1_FORCE_RESET();
|
||
__HAL_RCC_SDMMC1_RELEASE_RESET();
|
||
|
||
/* NVIC configuration for SDIO interrupts */
|
||
HAL_NVIC_SetPriority(SDMMC1_IRQn, 5, 0);
|
||
HAL_NVIC_EnableIRQ(SDMMC1_IRQn);
|
||
}
|
||
|
||
/**
|
||
* @brief DeInitializes the SD MSP.
|
||
* @param hsd: SD handle
|
||
* @param Params: Pointer to void
|
||
* @retval None
|
||
*/
|
||
__weak void BSP_SD_MspDeInit(SD_HandleTypeDef *hsd, void *Params)
|
||
{
|
||
/* Disable NVIC for SDIO interrupts */
|
||
HAL_NVIC_DisableIRQ(SDMMC1_IRQn);
|
||
|
||
/* DeInit GPIO pins can be done in the application
|
||
(by surcharging this __weak function) */
|
||
|
||
/* Disable SDMMC1 clock */
|
||
__HAL_RCC_SDMMC1_CLK_DISABLE();
|
||
|
||
/* GPIO pins clock and DMA clocks can be shut down in the application
|
||
by surcharging this __weak function */
|
||
}
|
||
|
||
/**
|
||
* @brief Gets the current SD card data status.
|
||
* @retval Data transfer state.
|
||
* This value can be one of the following values:
|
||
* @arg SD_TRANSFER_OK: No data transfer is acting
|
||
* @arg SD_TRANSFER_BUSY: Data transfer is acting
|
||
*/
|
||
uint8_t BSP_SD_GetCardState(void)
|
||
{
|
||
return ((HAL_SD_GetCardState(&uSdHandle) == HAL_SD_CARD_TRANSFER) ? SD_TRANSFER_OK : SD_TRANSFER_BUSY);
|
||
}
|
||
|
||
/**
|
||
* @brief Get SD information about specific SD card.
|
||
* @param CardInfo: Pointer to HAL_SD_CardInfoTypedef structure
|
||
* @retval None
|
||
*/
|
||
void BSP_SD_GetCardInfo(BSP_SD_CardInfo *CardInfo)
|
||
{
|
||
HAL_SD_GetCardInfo(&uSdHandle, CardInfo);
|
||
}
|
||
|
||
/**
|
||
* @brief BSP SD Abort callbacks
|
||
* @retval None
|
||
*/
|
||
__weak void BSP_SD_AbortCallback(void)
|
||
{
|
||
}
|
||
|
||
/**
|
||
* @brief BSP Tx Transfer completed callbacks
|
||
* @retval None
|
||
*/
|
||
__weak void BSP_SD_WriteCpltCallback(void)
|
||
{
|
||
}
|
||
|
||
/**
|
||
* @brief BSP Rx Transfer completed callbacks
|
||
* @retval None
|
||
*/
|
||
__weak void BSP_SD_ReadCpltCallback(void)
|
||
{
|
||
}
|
||
|
||
/**
|
||
* @brief BSP Error callbacks
|
||
* @retval None
|
||
*/
|
||
__weak void BSP_SD_ErrorCallback(void)
|
||
{
|
||
}
|
||
|
||
/**
|
||
* @brief BSP SD Transceiver 1.8V Mode Callback.
|
||
*/
|
||
__weak void BSP_SD_DriveTransciver_1_8V_Callback(FlagStatus status)
|
||
{
|
||
#if 0
|
||
if(status == SET)
|
||
{
|
||
BSP_IO_WritePin(IO_PIN_13, BSP_IO_PIN_SET);
|
||
}
|
||
else
|
||
{
|
||
BSP_IO_WritePin(IO_PIN_13, BSP_IO_PIN_RESET);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/**
|
||
* @brief SD Abort callbacks
|
||
* @param hsd: SD handle
|
||
* @retval None
|
||
*/
|
||
void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
|
||
{
|
||
BSP_SD_AbortCallback();
|
||
}
|
||
|
||
/**
|
||
* @brief Tx Transfer completed callbacks
|
||
* @param hsd: SD handle
|
||
* @retval None
|
||
*/
|
||
void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
|
||
{
|
||
BSP_SD_WriteCpltCallback();
|
||
}
|
||
|
||
/**
|
||
* @brief Rx Transfer completed callbacks
|
||
* @param hsd: SD handle
|
||
* @retval None
|
||
*/
|
||
void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
|
||
{
|
||
BSP_SD_ReadCpltCallback();
|
||
}
|
||
|
||
/**
|
||
* @brief Error callbacks
|
||
* @param hsd: SD handle
|
||
* @retval None
|
||
*/
|
||
void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
|
||
{
|
||
BSP_SD_ErrorCallback();
|
||
}
|
||
|
||
/**
|
||
* @brief Enable the SD Transceiver 1.8V Mode Callback.
|
||
*/
|
||
void HAL_SD_DriveTransciver_1_8V_Callback(FlagStatus status)
|
||
{
|
||
BSP_SD_DriveTransciver_1_8V_Callback(status);
|
||
}
|
||
|
||
void SDMMC1_IRQHandler(void)
|
||
{
|
||
HAL_SD_IRQHandler(&uSdHandle);
|
||
}
|
||
|
||
/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE****/
|