Mirror/inav
1
0
Fork 0
mirror of https://github.com/iNavFlight/inav.git synced 2025-07-13 11:29:56 +03:00
Code Issues Wiki Activity

f7: use hal for sdio

Browse source
This commit is contained in:
Marcelo Bezerra 2024-12-10 00:02:19 +01:00 • committed by bkleiner
parent 2dad829481
commit 3561feeb9f
15 changed files with 207 additions and 2259 deletions
Download patch file Download diff file Expand all files Collapse all files

4
cmake/stm32f7.cmake
View file

@ -38,6 +38,8 @@ set(STM32F7_HAL_SRC
stm32f7xx_ll_tim.c stm32f7xx_ll_tim.c
stm32f7xx_ll_usb.c stm32f7xx_ll_usb.c
stm32f7xx_ll_utils.c stm32f7xx_ll_utils.c
stm32f7xx_hal_sd.c
stm32f7xx_ll_sdmmc.c
) )
list(TRANSFORM STM32F7_HAL_SRC PREPEND "${STM32F7_HAL_DIR}/Src/") list(TRANSFORM STM32F7_HAL_SRC PREPEND "${STM32F7_HAL_DIR}/Src/")
@ -74,7 +76,7 @@ main_sources(STM32F7_SRC
drivers/system_stm32f7xx.c drivers/system_stm32f7xx.c
drivers/serial_uart_stm32f7xx.c drivers/serial_uart_stm32f7xx.c
drivers/serial_uart_hal.c drivers/serial_uart_hal.c
drivers/sdcard/sdmmc_sdio_f7xx.c drivers/sdcard/sdmmc_sdio_hal.c
) )
main_sources(STM32F7_MSC_SRC main_sources(STM32F7_MSC_SRC

2
cmake/stm32h7.cmake
View file

@ -161,7 +161,7 @@ main_sources(STM32H7_SRC
drivers/serial_uart_stm32h7xx.c drivers/serial_uart_stm32h7xx.c
drivers/serial_uart_hal.c drivers/serial_uart_hal.c
drivers/sdio.h drivers/sdio.h
drivers/sdcard/sdmmc_sdio_h7xx.c drivers/sdcard/sdmmc_sdio_hal.c
) )
main_sources(STM32H7_MSC_SRC main_sources(STM32H7_MSC_SRC

21
src/main/drivers/sdcard/sdcard_sdio.c
View file

@ -95,16 +95,23 @@ static bool sdcardSdio_isFunctional(void)
*/ */
static void sdcardSdio_reset(void) static void sdcardSdio_reset(void)
{ {
if (SD_Init() != 0) { if (!sdcard_isInserted()) {
sdcard.state = SDCARD_STATE_NOT_PRESENT;
return;
}
if (SD_Init() != SD_OK) {
sdcard.state = SDCARD_STATE_NOT_PRESENT;
return;
}
sdcard.failureCount++; sdcard.failureCount++;
if (sdcard.failureCount >= SDCARD_MAX_CONSECUTIVE_FAILURES || !sdcard_isInserted()) { if (sdcard.failureCount >= SDCARD_MAX_CONSECUTIVE_FAILURES) {
sdcard.state = SDCARD_STATE_NOT_PRESENT; sdcard.state = SDCARD_STATE_NOT_PRESENT;
} else { } else {
sdcard.operationStartTime = millis(); sdcard.operationStartTime = millis();
sdcard.state = SDCARD_STATE_RESET; sdcard.state = SDCARD_STATE_RESET;
} }
} }
}
typedef enum { typedef enum {
SDCARD_RECEIVE_SUCCESS, SDCARD_RECEIVE_SUCCESS,
@ -573,17 +580,13 @@ void sdcardSdio_init(void)
return; return;
} }
if (!SD_Initialize_LL(sdcard.dma->ref)) { if (!SD_Initialize_LL(sdcard.dma)) {
sdcard.dma = NULL; sdcard.dma = NULL;
sdcard.state = SDCARD_STATE_NOT_PRESENT; sdcard.state = SDCARD_STATE_NOT_PRESENT;
return; return;
} }
#else
if (!SD_Initialize_LL(0)) {
sdcard.state = SDCARD_STATE_NOT_PRESENT;
return;
}
#endif #endif
// We don't support hot insertion // We don't support hot insertion
if (!sdcard_isInserted()) { if (!sdcard_isInserted()) {
sdcard.state = SDCARD_STATE_NOT_PRESENT; sdcard.state = SDCARD_STATE_NOT_PRESENT;

21
src/main/drivers/sdcard/sdmmc_sdio.h
View file

@ -31,22 +31,7 @@
#if defined(USE_SDCARD_SDIO) #if defined(USE_SDCARD_SDIO)
#include "platform.h" #include "platform.h"
#include "drivers/dma.h"
#ifdef STM32F4
#include "stm32f4xx.h"
#endif
#ifdef STM32F7
#include "stm32f7xx.h"
#endif
#ifdef STM32H7
#include "stm32h7xx.h"
#endif
#ifdef AT32F43x
#include "at32f435_437.h"
#endif
/* SDCARD pinouts /* SDCARD pinouts
* *
@ -221,9 +206,9 @@ extern SD_CardType_t SD_CardType;
#ifdef AT32F43x #ifdef AT32F43x
// TODO:AT32 TARGES NOT USE SD CARD ANT TF CARD FOR NOW // TODO:AT32 TARGES NOT USE SD CARD ANT TF CARD FOR NOW
void SD_Initialize_LL (dma_channel_type *dma); void SD_Initialize_LL (DMA_t dma);
#else #else
bool SD_Initialize_LL (DMA_Stream_TypeDef *dma); bool SD_Initialize_LL (DMA_t dma);
#endif #endif
bool SD_Init(void); bool SD_Init(void);
bool SD_IsDetected(void); bool SD_IsDetected(void);

4
src/main/drivers/sdcard/sdmmc_sdio_f4xx.c
View file

@ -1356,8 +1356,10 @@ static SD_Error_t SD_FindSCR(uint32_t *pSCR)
/** /**
* @brief Initialize the SDIO module, DMA, and IO * @brief Initialize the SDIO module, DMA, and IO
*/ */
bool SD_Initialize_LL(DMA_Stream_TypeDef *dmaRef) bool SD_Initialize_LL(DMA_t dma)
{ {
DMA_Stream_TypeDef *dmaRef = dma->ref;
// Sanity check DMA stread - we only support two possible // Sanity check DMA stread - we only support two possible
if (((uint32_t)dmaRef != (uint32_t)DMA2_Stream3) && ((uint32_t)dmaRef != (uint32_t)DMA2_Stream6)) { if (((uint32_t)dmaRef != (uint32_t)DMA2_Stream3) && ((uint32_t)dmaRef != (uint32_t)DMA2_Stream6)) {
return false; return false;

1603
src/main/drivers/sdcard/sdmmc_sdio_f7xx.c
View file

File diff suppressed because it is too large Load diff

251
src/main/drivers/sdcard/sdmmc_sdio_h7xx.c → src/main/drivers/sdcard/sdmmc_sdio_hal.c
View file

@ -33,7 +33,6 @@
#ifdef USE_SDCARD_SDIO #ifdef USE_SDCARD_SDIO
#include "sdmmc_sdio.h" #include "sdmmc_sdio.h"
#include "stm32h7xx.h"
#include "drivers/sdio.h" #include "drivers/sdio.h"
#include "drivers/io.h" #include "drivers/io.h"
@ -53,12 +52,12 @@ typedef struct SD_Handle_s
volatile uint32_t TXCplt; // SD TX Complete is equal 0 when no transfer volatile uint32_t TXCplt; // SD TX Complete is equal 0 when no transfer
} SD_Handle_t; } SD_Handle_t;
SD_HandleTypeDef hsd1;
SD_CardInfo_t SD_CardInfo; SD_CardInfo_t SD_CardInfo;
SD_CardType_t SD_CardType; SD_CardType_t SD_CardType;
static SD_Handle_t SD_Handle; static SD_Handle_t SD_Handle;
static DMA_HandleTypeDef sd_dma;
static SD_HandleTypeDef hsd;
typedef struct sdioPin_s { typedef struct sdioPin_s {
ioTag_t pin; ioTag_t pin;
@ -75,6 +74,18 @@ typedef struct sdioPin_s {
#define SDIO_MAX_PINDEFS 2 #define SDIO_MAX_PINDEFS 2
#define IOCFG_SDMMC IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_NOPULL)
#ifdef STM32F7
#define SDMMC_CLK_DIV SDMMC_TRANSFER_CLK_DIV
#else
#if defined(SDCARD_SDIO_NORMAL_SPEED)
#define SDMMC_CLK_DIV SDMMC_NSpeed_CLK_DIV
#else
#define SDMMC_CLK_DIV SDMMC_HSpeed_CLK_DIV
#endif
#endif
typedef struct sdioHardware_s { typedef struct sdioHardware_s {
SDMMC_TypeDef *instance; SDMMC_TypeDef *instance;
IRQn_Type irqn; IRQn_Type irqn;
@ -90,6 +101,7 @@ typedef struct sdioHardware_s {
#define PINDEF(device, pin, afnum) { DEFIO_TAG_E(pin), GPIO_AF ## afnum ## _SDMMC ## device } #define PINDEF(device, pin, afnum) { DEFIO_TAG_E(pin), GPIO_AF ## afnum ## _SDMMC ## device }
#ifdef STM32H7
static const sdioHardware_t sdioPinHardware[SDIODEV_COUNT] = { static const sdioHardware_t sdioPinHardware[SDIODEV_COUNT] = {
{ {
.instance = SDMMC1, .instance = SDMMC1,
@ -112,6 +124,36 @@ static const sdioHardware_t sdioPinHardware[SDIODEV_COUNT] = {
.sdioPinD3 = { PINDEF(2, PB4, 9) }, .sdioPinD3 = { PINDEF(2, PB4, 9) },
} }
}; };
#endif
#ifdef STM32F7
static const sdioHardware_t sdioPinHardware[SDIODEV_COUNT] = {
{
.instance = SDMMC1,
.irqn = SDMMC1_IRQn,
.sdioPinCK = { PINDEF(1, PC12, 12) },
.sdioPinCMD = { PINDEF(1, PD2, 12) },
.sdioPinD0 = { PINDEF(1, PC8, 12) },
.sdioPinD1 = { PINDEF(1, PC9, 12) },
.sdioPinD2 = { PINDEF(1, PC10, 12) },
.sdioPinD3 = { PINDEF(1, PC11, 12) },
//.sdioPinD4 = { PINDEF(1, PB8, 12) },
//.sdioPinD5 = { PINDEF(1, PB9, 12) },
//.sdioPinD6 = { PINDEF(1, PC7, 12) },
//.sdioPinD7 = { PINDEF(1, PC11, 12) },
},
{
.instance = SDMMC2,
.irqn = SDMMC2_IRQn,
.sdioPinCK = { PINDEF(2, PD6, 11) },
.sdioPinCMD = { PINDEF(2, PD7, 11) },
.sdioPinD0 = { PINDEF(2, PB14, 10), PINDEF(2, PG0, 11) },
.sdioPinD1 = { PINDEF(2, PB15, 10), PINDEF(2, PG10, 11) },
.sdioPinD2 = { PINDEF(2, PB3, 10), PINDEF(2, PG11, 10) },
.sdioPinD3 = { PINDEF(2, PB4, 10), PINDEF(2, PG12, 11) },
}
};
#endif
#undef PINDEF #undef PINDEF
@ -139,19 +181,59 @@ void sdioPinConfigure(void)
#endif #endif
sdioPin[SDIO_PIN_D0] = sdioHardware->sdioPinD0[0]; sdioPin[SDIO_PIN_D0] = sdioHardware->sdioPinD0[0];
const IO_t clk = IOGetByTag(sdioPin[SDIO_PIN_CK].pin);
const IO_t cmd = IOGetByTag(sdioPin[SDIO_PIN_CMD].pin);
const IO_t d0 = IOGetByTag(sdioPin[SDIO_PIN_D0].pin);
IOInit(clk, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(cmd, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(d0, OWNER_SDCARD, RESOURCE_NONE, 0);
#ifdef SDCARD_SDIO_4BIT #ifdef SDCARD_SDIO_4BIT
sdioPin[SDIO_PIN_D1] = sdioHardware->sdioPinD1[0]; sdioPin[SDIO_PIN_D1] = sdioHardware->sdioPinD1[0];
sdioPin[SDIO_PIN_D2] = sdioHardware->sdioPinD2[0]; sdioPin[SDIO_PIN_D2] = sdioHardware->sdioPinD2[0];
sdioPin[SDIO_PIN_D3] = sdioHardware->sdioPinD3[0]; sdioPin[SDIO_PIN_D3] = sdioHardware->sdioPinD3[0];
const IO_t d1 = IOGetByTag(sdioPin[SDIO_PIN_D1].pin);
const IO_t d2 = IOGetByTag(sdioPin[SDIO_PIN_D2].pin);
const IO_t d3 = IOGetByTag(sdioPin[SDIO_PIN_D3].pin);
IOInit(d1, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(d2, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(d3, OWNER_SDCARD, RESOURCE_NONE, 0);
#endif #endif
//
// Setting all the SDIO pins to high for a short time results in more robust
// initialisation.
//
IOHi(d0);
IOConfigGPIO(d0, IOCFG_OUT_PP);
#ifdef SDCARD_SDIO_4BIT
IOHi(d1);
IOHi(d2);
IOHi(d3);
IOConfigGPIO(d1, IOCFG_OUT_PP);
IOConfigGPIO(d2, IOCFG_OUT_PP);
IOConfigGPIO(d3, IOCFG_OUT_PP);
#endif
IOHi(clk);
IOHi(cmd);
IOConfigGPIO(clk, IOCFG_OUT_PP);
IOConfigGPIO(cmd, IOCFG_OUT_PP);
} }
#define IOCFG_SDMMC IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_NOPULL) void SDMMC_DMA_IRQHandler(DMA_t channel)
{
UNUSED(channel);
HAL_DMA_IRQHandler(&sd_dma);
}
void HAL_SD_MspInit(SD_HandleTypeDef* hsd) void HAL_SD_MspInit(SD_HandleTypeDef* hsd)
{ {
UNUSED(hsd);
if (!sdioHardware) { if (!sdioHardware) {
return; return;
} }
@ -187,100 +269,89 @@ void HAL_SD_MspInit(SD_HandleTypeDef* hsd)
IOConfigGPIOAF(d3, IOCFG_SDMMC, sdioPin[SDIO_PIN_D3].af); IOConfigGPIOAF(d3, IOCFG_SDMMC, sdioPin[SDIO_PIN_D3].af);
#endif #endif
HAL_NVIC_SetPriority(sdioHardware->irqn, 0, 0); #ifdef STM32F7
sd_dma.Init.Direction = DMA_PERIPH_TO_MEMORY;
sd_dma.Init.PeriphInc = DMA_PINC_DISABLE;
sd_dma.Init.MemInc = DMA_MINC_ENABLE;
sd_dma.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
sd_dma.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
sd_dma.Init.Mode = DMA_PFCTRL;
sd_dma.Init.Priority = DMA_PRIORITY_LOW;
sd_dma.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
sd_dma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
sd_dma.Init.MemBurst = DMA_MBURST_INC4;
sd_dma.Init.PeriphBurst = DMA_PBURST_INC4;
dmaInit(dmaGetByRef(sd_dma.Instance), OWNER_SDCARD, 0);
if (HAL_DMA_Init(&sd_dma) != HAL_OK) {
return;
}
dmaSetHandler(dmaGetByRef(sd_dma.Instance), SDMMC_DMA_IRQHandler, 1, 0);
__HAL_LINKDMA(hsd, hdmarx, sd_dma);
__HAL_LINKDMA(hsd, hdmatx, sd_dma);
#else
UNUSED(hsd);
#endif
HAL_NVIC_SetPriority(sdioHardware->irqn, 2, 0);
HAL_NVIC_EnableIRQ(sdioHardware->irqn); HAL_NVIC_EnableIRQ(sdioHardware->irqn);
} }
void SDIO_GPIO_Init(void) bool SD_Initialize_LL(DMA_t dma)
{
if (!sdioHardware) {
return;
}
const IO_t clk = IOGetByTag(sdioPin[SDIO_PIN_CK].pin);
const IO_t cmd = IOGetByTag(sdioPin[SDIO_PIN_CMD].pin);
const IO_t d0 = IOGetByTag(sdioPin[SDIO_PIN_D0].pin);
const IO_t d1 = IOGetByTag(sdioPin[SDIO_PIN_D1].pin);
const IO_t d2 = IOGetByTag(sdioPin[SDIO_PIN_D2].pin);
const IO_t d3 = IOGetByTag(sdioPin[SDIO_PIN_D3].pin);
IOInit(clk, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(cmd, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(d0, OWNER_SDCARD, RESOURCE_NONE, 0);
#ifdef SDCARD_SDIO_4BIT
IOInit(d1, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(d2, OWNER_SDCARD, RESOURCE_NONE, 0);
IOInit(d3, OWNER_SDCARD, RESOURCE_NONE, 0);
#endif
//
// Setting all the SDIO pins to high for a short time results in more robust initialisation.
//
IOHi(d0);
IOConfigGPIO(d0, IOCFG_OUT_PP);
#ifdef SDCARD_SDIO_4BIT
IOHi(d1);
IOHi(d2);
IOHi(d3);
IOConfigGPIO(d1, IOCFG_OUT_PP);
IOConfigGPIO(d2, IOCFG_OUT_PP);
IOConfigGPIO(d3, IOCFG_OUT_PP);
#endif
IOHi(clk);
IOHi(cmd);
IOConfigGPIO(clk, IOCFG_OUT_PP);
IOConfigGPIO(cmd, IOCFG_OUT_PP);
}
bool SD_Initialize_LL(DMA_Stream_TypeDef *dma)
{ {
#ifdef STM32F7
sd_dma.Instance = dma->ref;
sd_dma.Init.Channel = dmaGetChannelByTag(SDCARD_SDIO_DMA);
#else
UNUSED(dma); UNUSED(dma);
#endif
return true; return true;
} }
bool SD_GetState(void) bool SD_GetState(void)
{ {
HAL_SD_CardStateTypedef cardState = HAL_SD_GetCardState(&hsd1); HAL_SD_CardStateTypedef cardState = HAL_SD_GetCardState(&hsd);
return (cardState == HAL_SD_CARD_TRANSFER); return (cardState == HAL_SD_CARD_TRANSFER);
} }
bool SD_Init(void) bool SD_Init(void)
{ {
memset(&hsd1, 0, sizeof(hsd1)); memset(&hsd, 0, sizeof(hsd));
hsd1.Instance = sdioHardware->instance; hsd.Instance = sdioHardware->instance;
// falling seems to work better ?? no idea whats "right" here // falling seems to work better ?? no idea whats "right" here
hsd1.Init.ClockEdge = SDMMC_CLOCK_EDGE_FALLING; hsd.Init.ClockEdge = SDMMC_CLOCK_EDGE_FALLING;
// drastically increases the time to respond from the sdcard // drastically increases the time to respond from the sdcard
// lets leave it off // lets leave it off
hsd1.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE; hsd.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
#ifdef SDCARD_SDIO_4BIT #ifdef STM32F7
hsd1.Init.BusWide = SDMMC_BUS_WIDE_4B; hsd.Init.ClockBypass = SDMMC_CLOCK_BYPASS_DISABLE;
#else
hsd1.Init.BusWide = SDMMC_BUS_WIDE_1B;
#endif
hsd1.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_ENABLE;
#ifdef SDCARD_SDIO_NORMAL_SPEED
hsd1.Init.ClockDiv = SDMMC_NSpeed_CLK_DIV;
#else
hsd1.Init.ClockDiv = SDMMC_HSpeed_CLK_DIV; // lets not go too crazy :)
#endif #endif
hsd.Init.BusWide = SDMMC_BUS_WIDE_1B;
hsd.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_ENABLE;
hsd.Init.ClockDiv = SDMMC_CLK_DIV;
// Will call HAL_SD_MspInit // Will call HAL_SD_MspInit
const HAL_StatusTypeDef status = HAL_SD_Init(&hsd1); if (HAL_SD_Init(&hsd) != HAL_OK) {
if (status != HAL_OK) { return SD_ERROR;
}
if (hsd.SdCard.BlockNbr == 0) {
return SD_ERROR; return SD_ERROR;
} }
switch(hsd1.SdCard.CardType) { #ifdef SDCARD_SDIO_4BIT
if (HAL_SD_ConfigWideBusOperation(&hsd, SDMMC_BUS_WIDE_4B) != HAL_OK) {
return SD_ERROR;
}
#endif
switch(hsd.SdCard.CardType) {
case CARD_SDSC: case CARD_SDSC:
switch (hsd1.SdCard.CardVersion) { switch (hsd.SdCard.CardVersion) {
case CARD_V1_X: case CARD_V1_X:
SD_CardType = SD_STD_CAPACITY_V1_1; SD_CardType = SD_STD_CAPACITY_V1_1;
break; break;
@ -300,11 +371,11 @@ bool SD_Init(void)
return SD_ERROR; return SD_ERROR;
} }
// STATIC_ASSERT(sizeof(SD_Handle.CSD) == sizeof(hsd1.CSD), hal-csd-size-error); // STATIC_ASSERT(sizeof(SD_Handle.CSD) == sizeof(hsd.CSD), hal-csd-size-error);
memcpy(&SD_Handle.CSD, &hsd1.CSD, sizeof(SD_Handle.CSD)); memcpy(&SD_Handle.CSD, &hsd.CSD, sizeof(SD_Handle.CSD));
// STATIC_ASSERT(sizeof(SD_Handle.CID) == sizeof(hsd1.CID), hal-cid-size-error); // STATIC_ASSERT(sizeof(SD_Handle.CID) == sizeof(hsd.CID), hal-cid-size-error);
memcpy(&SD_Handle.CID, &hsd1.CID, sizeof(SD_Handle.CID)); memcpy(&SD_Handle.CID, &hsd.CID, sizeof(SD_Handle.CID));
return SD_OK; return SD_OK;
} }
@ -529,15 +600,24 @@ SD_Error_t SD_WriteBlocks_DMA(uint64_t WriteAddress, uint32_t *buffer, uint32_t
return SD_ERROR; // unsupported. return SD_ERROR; // unsupported.
} }
#ifndef STM32F7
if ((uint32_t)buffer & 0x1f) { if ((uint32_t)buffer & 0x1f) {
return SD_ADDR_MISALIGNED; return SD_ADDR_MISALIGNED;
} }
#endif
// Ensure the data is flushed to main memory // Ensure the data is flushed to main memory
SCB_CleanDCache_by_Addr(buffer, NumberOfBlocks * BlockSize); SCB_CleanDCache_by_Addr(buffer, NumberOfBlocks * BlockSize);
HAL_StatusTypeDef status; #ifdef STM32F7
if ((status = HAL_SD_WriteBlocks_DMA(&hsd1, (uint8_t *)buffer, WriteAddress, NumberOfBlocks)) != HAL_OK) { if (sd_dma.Init.Direction != DMA_MEMORY_TO_PERIPH) {
sd_dma.Init.Direction = DMA_MEMORY_TO_PERIPH;
if (HAL_DMA_Init(&sd_dma) != HAL_OK) {
return SD_ERROR;
}
}
#endif
if (HAL_SD_WriteBlocks_DMA(&hsd, (uint8_t *)buffer, WriteAddress, NumberOfBlocks) != HAL_OK) {
return SD_ERROR; return SD_ERROR;
} }
@ -560,9 +640,11 @@ SD_Error_t SD_ReadBlocks_DMA(uint64_t ReadAddress, uint32_t *buffer, uint32_t Bl
return SD_ERROR; // unsupported. return SD_ERROR; // unsupported.
} }
#ifndef STM32F7
if ((uint32_t)buffer & 0x1f) { if ((uint32_t)buffer & 0x1f) {
return SD_ADDR_MISALIGNED; return SD_ADDR_MISALIGNED;
} }
#endif
SD_Handle.RXCplt = 1; SD_Handle.RXCplt = 1;
@ -570,8 +652,15 @@ SD_Error_t SD_ReadBlocks_DMA(uint64_t ReadAddress, uint32_t *buffer, uint32_t Bl
sdReadParameters.BlockSize = BlockSize; sdReadParameters.BlockSize = BlockSize;
sdReadParameters.NumberOfBlocks = NumberOfBlocks; sdReadParameters.NumberOfBlocks = NumberOfBlocks;
HAL_StatusTypeDef status; #ifdef STM32F7
if ((status = HAL_SD_ReadBlocks_DMA(&hsd1, (uint8_t *)buffer, ReadAddress, NumberOfBlocks)) != HAL_OK) { if (sd_dma.Init.Direction != DMA_PERIPH_TO_MEMORY) {
sd_dma.Init.Direction = DMA_PERIPH_TO_MEMORY;
if (HAL_DMA_Init(&sd_dma) != HAL_OK) {
return SD_ERROR;
}
}
#endif
if (HAL_SD_ReadBlocks_DMA(&hsd, (uint8_t *)buffer, ReadAddress, NumberOfBlocks) != HAL_OK) {
return SD_ERROR; return SD_ERROR;
} }
@ -619,12 +708,12 @@ void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
void SDMMC1_IRQHandler(void) void SDMMC1_IRQHandler(void)
{ {
HAL_SD_IRQHandler(&hsd1); HAL_SD_IRQHandler(&hsd);
} }
void SDMMC2_IRQHandler(void) void SDMMC2_IRQHandler(void)
{ {
HAL_SD_IRQHandler(&hsd1); HAL_SD_IRQHandler(&hsd);
} }
#endif #endif

3
src/main/drivers/sdio.h
View file

@ -29,7 +29,6 @@ typedef enum {
#define SDIODEV_COUNT 2 #define SDIODEV_COUNT 2
#if defined(STM32H7) #if defined(STM32H7) || defined(STM32F7)
void sdioPinConfigure(void); void sdioPinConfigure(void);
void SDIO_GPIO_Init(void);
#endif #endif

241
src/main/drivers/sdmmc_sdio.h
View file

@ -1,241 +0,0 @@
/*
* This file is part of Cleanflight and Betaflight.
*
* Cleanflight and Betaflight are free software. You can redistribute
* this software and/or modify this software under the terms of the
* GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option)
* any later version.
*
* Cleanflight and Betaflight are distributed in the hope that they
* will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software.
*
* If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Original author: Alain (https://github.com/aroyer-qc)
* Modified for F4 and BF source: Chris Hockuba (https://github.com/conkerkh)
*
*/
#ifndef __fatfs_sd_sdio_H__
#define __fatfs_sd_sdio_H__
#include <stdint.h>
#include "platform.h"
#ifdef STM32F4
#include "stm32f4xx.h"
#endif
#ifdef STM32F7
#include "stm32f7xx.h"
#endif
/* SDCARD pinouts
*
* SD CARD PINS
_________________
/ 1 2 3 4 5 6 7 8 | NR |SDIO INTERFACE
/ | |NAME STM32F746 DESCRIPTION
/ 9 | | 4-BIT 1-BIT
| | |
| | 1 |CD/DAT3 PC11 - Connector data line 3
| | 2 |CMD PD2 PD2 Command/Response line
| | 3 |VSS1 GND GND GND
| SD CARD Pinout | 4 |VDD 3.3V 3.3V 3.3V Power supply
| | 5 |CLK PC12 PC12 Clock
| | 6 |VSS2 GND GND GND
| | 7 |DAT0 PC8 PC8 Connector data line 0
| | 8 |DAT1 PC9 - Connector data line 1
|___________________| 9 |DAT2 PC10 - Connector data line 2
*/
/* Define(s) --------------------------------------------------------------------------------------------------------*/
//#define MSD_OK ((uint8_t)0x00)
#define MSD_ERROR ((uint8_t)0x01)
#define MSD_ERROR_SD_NOT_PRESENT ((uint8_t)0x02)
#define SD_PRESENT ((uint8_t)0x01)
#define SD_NOT_PRESENT ((uint8_t)0x00)
#define SD_DATATIMEOUT ((uint32_t)100000000)
#define SD_DETECT_GPIO_PORT GPIOC
#define SD_DETECT_PIN GPIO_PIN_13
/* Structure(s) -----------------------------------------------------------------------------------------------------*/
typedef enum
{
// SD specific error defines
SD_CMD_CRC_FAIL = (1), // Command response received (but CRC check failed)
SD_DATA_CRC_FAIL = (2), // Data block sent/received (CRC check failed)
SD_CMD_RSP_TIMEOUT = (3), // Command response TimeOut
SD_DATA_TIMEOUT = (4), // Data TimeOut
SD_TX_UNDERRUN = (5), // Transmit FIFO underrun
SD_RX_OVERRUN = (6), // Receive FIFO overrun
SD_START_BIT_ERR = (7), // Start bit not detected on all data signals in wide bus mode
SD_CMD_OUT_OF_RANGE = (8), // Command's argument was out of range.
SD_ADDR_MISALIGNED = (9), // Misaligned address
SD_BLOCK_LEN_ERR = (10), // Transferred block length is not allowed for the card or the number of transferred bytes does not match the block length
SD_ERASE_SEQ_ERR = (11), // An error in the sequence of erase command occurs.
SD_BAD_ERASE_PARAM = (12), // An invalid selection for erase groups
SD_WRITE_PROT_VIOLATION = (13), // Attempt to program a write protect block
SD_LOCK_UNLOCK_FAILED = (14), // Sequence or password error has been detected in unlock command or if there was an attempt to access a locked card
SD_COM_CRC_FAILED = (15), // CRC check of the previous command failed
SD_ILLEGAL_CMD = (16), // Command is not legal for the card state
SD_CARD_ECC_FAILED = (17), // Card internal ECC was applied but failed to correct the data
SD_CC_ERROR = (18), // Internal card controller error
SD_GENERAL_UNKNOWN_ERROR = (19), // General or unknown error
SD_STREAM_READ_UNDERRUN = (20), // The card could not sustain data transfer in stream read operation.
SD_STREAM_WRITE_OVERRUN = (21), // The card could not sustain data programming in stream mode
SD_CID_CSD_OVERWRITE = (22), // CID/CSD overwrite error
SD_WP_ERASE_SKIP = (23), // Only partial address space was erased
SD_CARD_ECC_DISABLED = (24), // Command has been executed without using internal ECC
SD_ERASE_RESET = (25), // Erase sequence was cleared before executing because an out of erase sequence command was received
SD_AKE_SEQ_ERROR = (26), // Error in sequence of authentication.
SD_INVALID_VOLTRANGE = (27),
SD_ADDR_OUT_OF_RANGE = (28),
SD_SWITCH_ERROR = (29),
SD_SDMMC_DISABLED = (30),
SD_SDMMC_FUNCTION_BUSY = (31),
SD_SDMMC_FUNCTION_FAILED = (32),
SD_SDMMC_UNKNOWN_FUNCTION = (33),
SD_OUT_OF_BOUND = (34),
// Standard error defines
SD_INTERNAL_ERROR = (35),
SD_NOT_CONFIGURED = (36),
SD_REQUEST_PENDING = (37),
SD_REQUEST_NOT_APPLICABLE = (38),
SD_INVALID_PARAMETER = (39),
SD_UNSUPPORTED_FEATURE = (40),
SD_UNSUPPORTED_HW = (41),
SD_ERROR = (42),
SD_BUSY = (43),
SD_OK = (0)
} SD_Error_t;
typedef struct
{
uint8_t DAT_BUS_WIDTH; // Shows the currently defined data bus width
uint8_t SECURED_MODE; // Card is in secured mode of operation
uint16_t SD_CARD_TYPE; // Carries information about card type
uint32_t SIZE_OF_PROTECTED_AREA; // Carries information about the capacity of protected area
uint8_t SPEED_CLASS; // Carries information about the speed class of the card
uint8_t PERFORMANCE_MOVE; // Carries information about the card's performance move
uint8_t AU_SIZE; // Carries information about the card's allocation unit size
uint16_t ERASE_SIZE; // Determines the number of AUs to be erased in one operation
uint8_t ERASE_TIMEOUT; // Determines the TimeOut for any number of AU erase
uint8_t ERASE_OFFSET; // Carries information about the erase offset
} SD_CardStatus_t;
typedef struct
{
uint8_t CSDStruct; // CSD structure
uint8_t SysSpecVersion; // System specification version
uint8_t Reserved1; // Reserved
uint8_t TAAC; // Data read access time 1
uint8_t NSAC; // Data read access time 2 in CLK cycles
uint8_t MaxBusClkFrec; // Max. bus clock frequency
uint16_t CardComdClasses; // Card command classes
uint8_t RdBlockLen; // Max. read data block length
uint8_t PartBlockRead; // Partial blocks for read allowed
uint8_t WrBlockMisalign; // Write block misalignment
uint8_t RdBlockMisalign; // Read block misalignment
uint8_t DSRImpl; // DSR implemented
uint8_t Reserved2; // Reserved
uint32_t DeviceSize; // Device Size
uint8_t MaxRdCurrentVDDMin; // Max. read current @ VDD min
uint8_t MaxRdCurrentVDDMax; // Max. read current @ VDD max
uint8_t MaxWrCurrentVDDMin; // Max. write current @ VDD min
uint8_t MaxWrCurrentVDDMax; // Max. write current @ VDD max
uint8_t DeviceSizeMul; // Device size multiplier
uint8_t EraseGrSize; // Erase group size
uint8_t EraseGrMul; // Erase group size multiplier
uint8_t WrProtectGrSize; // Write protect group size
uint8_t WrProtectGrEnable; // Write protect group enable
uint8_t ManDeflECC; // Manufacturer default ECC
uint8_t WrSpeedFact; // Write speed factor
uint8_t MaxWrBlockLen; // Max. write data block length
uint8_t WriteBlockPaPartial; // Partial blocks for write allowed
uint8_t Reserved3; // Reserved
uint8_t ContentProtectAppli; // Content protection application
uint8_t FileFormatGrouop; // File format group
uint8_t CopyFlag; // Copy flag (OTP)
uint8_t PermWrProtect; // Permanent write protection
uint8_t TempWrProtect; // Temporary write protection
uint8_t FileFormat; // File format
uint8_t ECC; // ECC code
uint8_t CSD_CRC; // CSD CRC
uint8_t Reserved4; // Always 1
} SD_CSD_t;
typedef struct
{
uint8_t ManufacturerID; // Manufacturer ID
uint16_t OEM_AppliID; // OEM/Application ID
uint32_t ProdName1; // Product Name part1
uint8_t ProdName2; // Product Name part2
uint8_t ProdRev; // Product Revision
uint32_t ProdSN; // Product Serial Number
uint8_t Reserved1; // Reserved1
uint16_t ManufactDate; // Manufacturing Date
uint8_t CID_CRC; // CID CRC
uint8_t Reserved2; // Always 1
} SD_CID_t;
typedef enum
{
SD_STD_CAPACITY_V1_1 = 0,
SD_STD_CAPACITY_V2_0 = 1,
SD_HIGH_CAPACITY = 2,
SD_MULTIMEDIA = 3,
SD_SECURE_DIGITAL_IO = 4,
SD_HIGH_SPEED_MULTIMEDIA = 5,
SD_SECURE_DIGITAL_IO_COMBO = 6,
SD_HIGH_CAPACITY_MMC = 7,
} SD_CardType_t;
typedef struct
{
volatile SD_CSD_t SD_csd; // SD card specific data register
volatile SD_CID_t SD_cid; // SD card identification number register
uint64_t CardCapacity; // Card capacity
uint32_t CardBlockSize; // Card block size
} SD_CardInfo_t;
/* Prototype(s) -----------------------------------------------------------------------------------------------------*/
extern SD_CardInfo_t SD_CardInfo;
extern SD_CardType_t SD_CardType;
void SD_Initialize_LL (DMA_Stream_TypeDef *dma);
bool SD_Init (void);
bool SD_IsDetected (void);
bool SD_GetState (void);
SD_Error_t SD_GetCardInfo (void);
SD_Error_t SD_ReadBlocks_DMA (uint64_t ReadAddress, uint32_t *buffer, uint32_t BlockSize, uint32_t NumberOfBlocks);
SD_Error_t SD_CheckRead (void);
SD_Error_t SD_WriteBlocks_DMA (uint64_t WriteAddress, uint32_t *buffer, uint32_t BlockSize, uint32_t NumberOfBlocks);
SD_Error_t SD_CheckWrite (void);
SD_Error_t SD_Erase (uint64_t StartAddress, uint64_t EndAddress);
SD_Error_t SD_GetCardStatus (SD_CardStatus_t* pCardStatus);
/* ------------------------------------------------------------------------------------------------------------------*/
#endif // __fatfs_sd_sdio_H__

2
src/main/drivers/usb_msc_f4xx.c
View file

@ -42,7 +42,7 @@
#include "drivers/light_led.h" #include "drivers/light_led.h"
#include "drivers/nvic.h" #include "drivers/nvic.h"
#include "drivers/persistent.h" #include "drivers/persistent.h"
#include "drivers/sdmmc_sdio.h" #include "drivers/sdcard/sdmmc_sdio.h"
#include "drivers/time.h" #include "drivers/time.h"
#include "drivers/usb_msc.h" #include "drivers/usb_msc.h"

3
src/main/fc/fc_init.c
View file

@ -372,9 +372,8 @@ void init(void)
updateHardwareRevision(); updateHardwareRevision();
#endif #endif
#if defined(USE_SDCARD_SDIO) && defined(STM32H7) #if defined(USE_SDCARD_SDIO) && (defined(STM32H7) || defined(STM32F7))
sdioPinConfigure(); sdioPinConfigure();
SDIO_GPIO_Init();
#endif #endif
#ifdef USE_USB_MSC #ifdef USE_USB_MSC

3
src/main/msc/usbd_storage_sd_spi.c
View file

@ -213,7 +213,8 @@ static int8_t STORAGE_Read (uint8_t lun,
UNUSED(lun); UNUSED(lun);
LED1_ON; LED1_ON;
for (int i = 0; i < blk_len; i++) { for (int i = 0; i < blk_len; i++) {
while (sdcard_readBlock(blk_addr + i, buf + (512 * i), NULL, 0) == 0); while (sdcard_readBlock(blk_addr + i, buf + (512 * i), NULL, 0) == 0)
sdcard_poll();
while (sdcard_poll() == 0); while (sdcard_poll() == 0);
} }
LED1_OFF; LED1_OFF;

289
src/main/msc/usbd_storage_sdio.c
View file

@ -1,289 +0,0 @@
/**
******************************************************************************
* @file usbd_storage_template.c
* @author MCD Application Team
* @version V1.2.0
* @date 09-November-2015
* @brief Memory management layer
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.st.com/software_license_agreement_liberty_v2
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include <stdio.h>
#include <stdbool.h>
#include "platform.h"
#include "drivers/sdmmc_sdio.h"
#include "drivers/light_led.h"
#include "drivers/io.h"
#include "common/utils.h"
#ifdef USE_HAL_DRIVER
#include "usbd_msc.h"
#else
#include "usbd_msc_mem.h"
#include "usbd_msc_core.h"
#endif
#include "usbd_storage.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Extern function prototypes ------------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/* USB NVIC Priority has to be lower than both DMA and SDIO priority,
* otherwise SDIO won't be able to preempt USB.
*/
#define STORAGE_LUN_NBR 1
#define STORAGE_BLK_NBR 0x10000
#define STORAGE_BLK_SIZ 0x200
static int8_t STORAGE_Init (uint8_t lun);
#ifdef USE_HAL_DRIVER
static int8_t STORAGE_GetCapacity (uint8_t lun,
uint32_t *block_num,
uint16_t *block_size);
#else
static int8_t STORAGE_GetCapacity (uint8_t lun,
uint32_t *block_num,
uint32_t *block_size);
#endif
static int8_t STORAGE_IsReady (uint8_t lun);
static int8_t STORAGE_IsWriteProtected (uint8_t lun);
static int8_t STORAGE_Read (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len);
static int8_t STORAGE_Write (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len);
static int8_t STORAGE_GetMaxLun (void);
/* USB Mass storage Standard Inquiry Data */
static uint8_t STORAGE_Inquirydata[] = {//36
/* LUN 0 */
0x00,
0x80,
0x02,
0x02,
#ifdef USE_HAL_DRIVER
(STANDARD_INQUIRY_DATA_LEN - 5),
#else
(USBD_STD_INQUIRY_LENGTH - 5),
#endif
0x00,
0x00,
0x00,
'S', 'T', 'M', ' ', ' ', ' ', ' ', ' ', /* Manufacturer : 8 bytes */
'P', 'r', 'o', 'd', 'u', 't', ' ', ' ', /* Product : 16 Bytes */
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
'0', '.', '0' ,'1', /* Version : 4 Bytes */
};
#ifdef USE_HAL_DRIVER
USBD_StorageTypeDef USBD_MSC_MICRO_SDIO_fops =
{
STORAGE_Init,
STORAGE_GetCapacity,
STORAGE_IsReady,
STORAGE_IsWriteProtected,
STORAGE_Read,
STORAGE_Write,
STORAGE_GetMaxLun,
(int8_t*)STORAGE_Inquirydata,
};
#else
USBD_STORAGE_cb_TypeDef USBD_MSC_MICRO_SDIO_fops =
{
STORAGE_Init,
STORAGE_GetCapacity,
STORAGE_IsReady,
STORAGE_IsWriteProtected,
STORAGE_Read,
STORAGE_Write,
STORAGE_GetMaxLun,
(int8_t*)STORAGE_Inquirydata,
};
#endif
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the microSD card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
static int8_t STORAGE_Init (uint8_t lun)
{
//Initialize SD_DET
#ifdef SDCARD_DETECT_PIN
const IO_t sd_det = IOGetByTag(IO_TAG(SDCARD_DETECT_PIN));
IOInit(sd_det, OWNER_SDCARD_DETECT, 0);
IOConfigGPIO(sd_det, IOCFG_IPU);
#endif
UNUSED(lun);
LED0_OFF;
#if defined(STM32H7) // H7 uses IDMA
SD_Initialize_LL(0);
#else
SD_Initialize_LL(SDIO_DMA);
#endif
if (SD_Init() != 0) return 1;
LED0_ON;
return 0;
}
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the STORAGE card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
#ifdef USE_HAL_DRIVER
static int8_t STORAGE_GetCapacity (uint8_t lun, uint32_t *block_num, uint16_t *block_size)
#else
static int8_t STORAGE_GetCapacity (uint8_t lun, uint32_t *block_num, uint32_t *block_size)
#endif
{
UNUSED(lun);
if (SD_IsDetected() == 0) {
return -1;
}
SD_GetCardInfo();
*block_num = SD_CardInfo.CardCapacity;
*block_size = 512;
return (0);
}
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the STORAGE card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
static int8_t STORAGE_IsReady (uint8_t lun)
{
UNUSED(lun);
int8_t ret = -1;
if (SD_GetState() == true && SD_IsDetected() == SD_PRESENT) {
ret = 0;
}
return ret;
}
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the STORAGE card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
static int8_t STORAGE_IsWriteProtected (uint8_t lun)
{
UNUSED(lun);
return 0;
}
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the STORAGE card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
static int8_t STORAGE_Read (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len)
{
UNUSED(lun);
if (SD_IsDetected() == 0) {
return -1;
}
LED1_ON;
//buf should be 32bit aligned, but usually is so we don't do byte alignment
if (SD_ReadBlocks_DMA(blk_addr, (uint32_t*) buf, 512, blk_len) == 0) {
while (SD_CheckRead());
while(SD_GetState() == false);
LED1_OFF;
return 0;
}
LED1_OFF;
return -1;
}
/*******************************************************************************
* Function Name : Write_Memory
* Description : Handle the Write operation to the STORAGE card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
static int8_t STORAGE_Write (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len)
{
UNUSED(lun);
if (SD_IsDetected() == 0) {
return -1;
}
LED1_ON;
//buf should be 32bit aligned, but usually is so we don't do byte alignment
if (SD_WriteBlocks_DMA(blk_addr, (uint32_t*) buf, 512, blk_len) == 0) {
while (SD_CheckWrite());
while(SD_GetState() == false);
LED1_OFF;
return 0;
}
LED1_OFF;
return -1;
}
/*******************************************************************************
* Function Name : Write_Memory
* Description : Handle the Write operation to the STORAGE card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
static int8_t STORAGE_GetMaxLun (void)
{
return (STORAGE_LUN_NBR - 1);
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

1
src/main/target/MATEKF765/target.h
View file

@ -169,6 +169,7 @@
#define USE_SDCARD_SDIO #define USE_SDCARD_SDIO
#define SDCARD_SDIO_DMA DMA_TAG(2,3,4) #define SDCARD_SDIO_DMA DMA_TAG(2,3,4)
#define SDCARD_SDIO_4BIT #define SDCARD_SDIO_4BIT
#define SDCARD_SDIO_DEVICE SDIODEV_1
#define ENABLE_BLACKBOX_LOGGING_ON_SDCARD_BY_DEFAULT #define ENABLE_BLACKBOX_LOGGING_ON_SDCARD_BY_DEFAULT
// *************** ADC ***************************** // *************** ADC *****************************

2
src/main/target/stm32f7xx_hal_conf.h
View file

@ -71,7 +71,7 @@
/* #define HAL_RNG_MODULE_ENABLED */ /* #define HAL_RNG_MODULE_ENABLED */
#define HAL_RTC_MODULE_ENABLED #define HAL_RTC_MODULE_ENABLED
/* #define HAL_SAI_MODULE_ENABLED */ /* #define HAL_SAI_MODULE_ENABLED */
/* #define HAL_SD_MODULE_ENABLED */ #define HAL_SD_MODULE_ENABLED
/* #define HAL_MMC_MODULE_ENABLED */ /* #define HAL_MMC_MODULE_ENABLED */
/* #define HAL_SPDIFRX_MODULE_ENABLED */ /* #define HAL_SPDIFRX_MODULE_ENABLED */
#define HAL_SPI_MODULE_ENABLED #define HAL_SPI_MODULE_ENABLED