From 22d05674495292f045fd4b4794f71d3b0a672847 Mon Sep 17 00:00:00 2001 From: Johnny Hsu Date: Wed, 2 Apr 2025 01:42:04 +0200 Subject: [PATCH] sdram test --- Hardware/Lib/KiCAD_Libraries | 2 +- Software/.mxproject | 16 +- Software/Core/Inc/stm32h7xx_hal_conf.h | 2 +- Software/Core/Src/main.c | 161 +- Software/Core/Src/stm32h7xx_hal_msp.c | 126 +- .../Inc/stm32h7xx_hal_mmc.h | 877 --- .../Inc/stm32h7xx_hal_mmc_ex.h | 113 - .../Inc/stm32h7xx_hal_sd.h | 802 --- .../Inc/stm32h7xx_hal_sd_ex.h | 112 - .../Inc/stm32h7xx_ll_delayblock.h | 93 - .../Inc/stm32h7xx_ll_sdmmc.h | 1284 ---- .../Src/stm32h7xx_hal_mmc.c | 5964 ----------------- .../Src/stm32h7xx_hal_mmc_ex.c | 353 - .../Src/stm32h7xx_hal_sd.c | 4150 ------------ .../Src/stm32h7xx_hal_sd_ex.c | 315 - .../Src/stm32h7xx_ll_delayblock.c | 214 - .../Src/stm32h7xx_ll_sdmmc.c | 1874 ------ Software/FT23_Charger.ioc | 318 +- Software/Makefile | 104 +- Software/STM32Make.make | 6 - Software/build/FT23_Charger.map | 1999 +++--- 21 files changed, 1071 insertions(+), 17814 deletions(-) delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc.h delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc_ex.h delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd.h delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd_ex.h delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_delayblock.h delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_sdmmc.h delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c delete mode 100644 Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c diff --git a/Hardware/Lib/KiCAD_Libraries b/Hardware/Lib/KiCAD_Libraries index b15be55..624533a 160000 --- a/Hardware/Lib/KiCAD_Libraries +++ b/Hardware/Lib/KiCAD_Libraries @@ -1 +1 @@ -Subproject commit b15be55d65b357b8fe436e5c51fd7f6cef9aa4df +Subproject commit 624533a150f7256a011a23ce93407e9123ce12fb diff --git a/Software/.mxproject b/Software/.mxproject index d41ad76..59c5738 100644 --- a/Software/.mxproject +++ b/Software/.mxproject @@ -1,3 +1,11 @@ +[PreviousLibFiles] +LibFiles=Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_bus.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crs.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_system.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_utils.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dmamux.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mdma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_def.h;Drivers/STM32H7xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_fdcan.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_fmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nor.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nand.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sdram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_lpuart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usb.h;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_bus.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crs.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_system.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_utils.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dmamux.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mdma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_def.h;Drivers/STM32H7xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_fdcan.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_fmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nor.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nand.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sdram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_lpuart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usb.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/stm32h7a3xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/stm32h7xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/system_stm32h7xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/system_stm32h7xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Source/Templates/system_stm32h7xx.c;Drivers/CMSIS/Include/core_armv81mml.h;Drivers/CMSIS/Include/mpu_armv8.h;Drivers/CMSIS/Include/core_cm23.h;Drivers/CMSIS/Include/core_cm1.h;Drivers/CMSIS/Include/core_cm0.h;Drivers/CMSIS/Include/core_cm33.h;Drivers/CMSIS/Include/cmsis_gcc.h;Drivers/CMSIS/Include/cmsis_armclang.h;Drivers/CMSIS/Include/core_armv8mbl.h;Drivers/CMSIS/Include/cmsis_compiler.h;Drivers/CMSIS/Include/core_cm4.h;Drivers/CMSIS/Include/cmsis_iccarm.h;Drivers/CMSIS/Include/core_cm7.h;Drivers/CMSIS/Include/core_sc300.h;Drivers/CMSIS/Include/core_armv8mml.h;Drivers/CMSIS/Include/core_cm35p.h;Drivers/CMSIS/Include/cmsis_armclang_ltm.h;Drivers/CMSIS/Include/core_sc000.h;Drivers/CMSIS/Include/core_cm3.h;Drivers/CMSIS/Include/cmsis_armcc.h;Drivers/CMSIS/Include/core_cm0plus.h;Drivers/CMSIS/Include/tz_context.h;Drivers/CMSIS/Include/mpu_armv7.h;Drivers/CMSIS/Include/cmsis_version.h; + +[PreviousUsedMakefileFiles] +SourceFiles=Core/Src/main.c;Core/Src/stm32h7xx_it.c;Core/Src/stm32h7xx_hal_msp.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c;Drivers/CMSIS/Device/ST/STM32H7xx/Source/Templates/system_stm32h7xx.c;Core/Src/system_stm32h7xx.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c;Drivers/CMSIS/Device/ST/STM32H7xx/Source/Templates/system_stm32h7xx.c;Core/Src/system_stm32h7xx.c;;; +HeaderPath=Drivers/STM32H7xx_HAL_Driver/Inc;Drivers/STM32H7xx_HAL_Driver/Inc/Legacy;Drivers/CMSIS/Device/ST/STM32H7xx/Include;Drivers/CMSIS/Include;Core/Inc; +CDefines=USE_PWR_LDO_SUPPLY;USE_PWR_LDO_SUPPLY;USE_PWR_LDO_SUPPLY;USE_HAL_DRIVER;STM32H7A3xx;USE_HAL_DRIVER;USE_HAL_DRIVER; + [PreviousGenFiles] AdvancedFolderStructure=true HeaderFileListSize=3 @@ -15,11 +23,3 @@ SourceFolderListSize=1 SourcePath#0=../Core/Src SourceFiles=; -[PreviousLibFiles] -LibFiles=Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_bus.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crs.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_system.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_utils.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dmamux.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mdma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_def.h;Drivers/STM32H7xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_fdcan.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_fmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nor.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nand.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sdram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_sdmmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_delayblock.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_lpuart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usb.h;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_cortex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_crc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_rcc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_bus.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_rcc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_crs.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_system.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_utils.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_flash_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_gpio_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_gpio.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_hsem.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_dma_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_dmamux.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mdma.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pwr_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_pwr.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_def.h;Drivers/STM32H7xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_i2c_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_exti.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_fdcan.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_fmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nor.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_nand.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sdram.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_i2c.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_ltdc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_sdmmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_delayblock.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_lpuart.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_pcd_ex.h;Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_usb.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/stm32h7a3xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/stm32h7xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/system_stm32h7xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Include/system_stm32h7xx.h;Drivers/CMSIS/Device/ST/STM32H7xx/Source/Templates/system_stm32h7xx.c;Drivers/CMSIS/Include/core_armv81mml.h;Drivers/CMSIS/Include/mpu_armv8.h;Drivers/CMSIS/Include/core_cm23.h;Drivers/CMSIS/Include/core_cm1.h;Drivers/CMSIS/Include/core_cm0.h;Drivers/CMSIS/Include/core_cm33.h;Drivers/CMSIS/Include/cmsis_gcc.h;Drivers/CMSIS/Include/cmsis_armclang.h;Drivers/CMSIS/Include/core_armv8mbl.h;Drivers/CMSIS/Include/cmsis_compiler.h;Drivers/CMSIS/Include/core_cm4.h;Drivers/CMSIS/Include/cmsis_iccarm.h;Drivers/CMSIS/Include/core_cm7.h;Drivers/CMSIS/Include/core_sc300.h;Drivers/CMSIS/Include/core_armv8mml.h;Drivers/CMSIS/Include/core_cm35p.h;Drivers/CMSIS/Include/cmsis_armclang_ltm.h;Drivers/CMSIS/Include/core_sc000.h;Drivers/CMSIS/Include/core_cm3.h;Drivers/CMSIS/Include/cmsis_armcc.h;Drivers/CMSIS/Include/core_cm0plus.h;Drivers/CMSIS/Include/tz_context.h;Drivers/CMSIS/Include/mpu_armv7.h;Drivers/CMSIS/Include/cmsis_version.h; - -[PreviousUsedMakefileFiles] -SourceFiles=Core/Src/main.c;Core/Src/stm32h7xx_it.c;Core/Src/stm32h7xx_hal_msp.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c;Drivers/CMSIS/Device/ST/STM32H7xx/Source/Templates/system_stm32h7xx.c;Core/Src/system_stm32h7xx.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c;Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c;Drivers/CMSIS/Device/ST/STM32H7xx/Source/Templates/system_stm32h7xx.c;Core/Src/system_stm32h7xx.c;;; -HeaderPath=Drivers/STM32H7xx_HAL_Driver/Inc;Drivers/STM32H7xx_HAL_Driver/Inc/Legacy;Drivers/CMSIS/Device/ST/STM32H7xx/Include;Drivers/CMSIS/Include;Core/Inc; -CDefines=USE_PWR_LDO_SUPPLY;USE_PWR_LDO_SUPPLY;USE_PWR_LDO_SUPPLY;USE_HAL_DRIVER;STM32H7A3xx;USE_HAL_DRIVER;USE_HAL_DRIVER; - diff --git a/Software/Core/Inc/stm32h7xx_hal_conf.h b/Software/Core/Inc/stm32h7xx_hal_conf.h index b443863..7b3df5e 100644 --- a/Software/Core/Inc/stm32h7xx_hal_conf.h +++ b/Software/Core/Inc/stm32h7xx_hal_conf.h @@ -69,7 +69,7 @@ /* #define HAL_RNG_MODULE_ENABLED */ /* #define HAL_RTC_MODULE_ENABLED */ /* #define HAL_SAI_MODULE_ENABLED */ -#define HAL_SD_MODULE_ENABLED +/* #define HAL_SD_MODULE_ENABLED */ /* #define HAL_MMC_MODULE_ENABLED */ /* #define HAL_SPDIFRX_MODULE_ENABLED */ /* #define HAL_SPI_MODULE_ENABLED */ diff --git a/Software/Core/Src/main.c b/Software/Core/Src/main.c index 17cb70e..39f903a 100644 --- a/Software/Core/Src/main.c +++ b/Software/Core/Src/main.c @@ -21,6 +21,7 @@ /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ +#include /* USER CODE END Includes */ @@ -49,8 +50,6 @@ I2C_HandleTypeDef hi2c4; LTDC_HandleTypeDef hltdc; -SD_HandleTypeDef hsd2; - UART_HandleTypeDef huart5; UART_HandleTypeDef huart10; @@ -59,17 +58,15 @@ PCD_HandleTypeDef hpcd_USB_OTG_HS; SDRAM_HandleTypeDef hsdram1; /* USER CODE BEGIN PV */ -uint16_t framebuffer[480*272]; +// uint32_t framebuffer[480*272]; /* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/ void SystemClock_Config(void); -void PeriphCommonClock_Config(void); static void MX_GPIO_Init(void); static void MX_FDCAN1_Init(void); static void MX_FMC_Init(void); static void MX_I2C4_Init(void); -static void MX_SDMMC2_SD_Init(void); static void MX_USART10_UART_Init(void); static void MX_USB_OTG_HS_PCD_Init(void); static void MX_UART5_Init(void); @@ -107,9 +104,6 @@ int main(void) /* Configure the system clock */ SystemClock_Config(); - /* Configure the peripherals common clocks */ - PeriphCommonClock_Config(); - /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ @@ -119,21 +113,41 @@ int main(void) MX_FDCAN1_Init(); MX_FMC_Init(); MX_I2C4_Init(); - MX_SDMMC2_SD_Init(); MX_USART10_UART_Init(); MX_USB_OTG_HS_PCD_Init(); MX_UART5_Init(); MX_LTDC_Init(); MX_CRC_Init(); /* USER CODE BEGIN 2 */ - HAL_LTDC_SetAddress(&hltdc, (uint32_t)framebuffer, LTDC_LAYER_1); - uint8_t r = 0xff, g = 0x00, b = 0x00; // Solid red - uint16_t col = ((r>>3)<<11) | ((g>>2)<<5) | (b>>3); // Convert colors to RGB565 - // Put colors into the framebuffer - for(int i = 0; i < 480*272; i++) - { - framebuffer[i] = col; - } + // uint8_t r = 0xff, g = 0xff, b = 0xff; // Solid red + // uint32_t col = ((r>>2)<<12) | ((g>>2)<<6) | (b>>2); // Convert colors to RGB565 + // // Put colors into the framebuffer + // for(int i = 0; i < 480*272; i++) + // { + // framebuffer[i] = col; + // } + + // HAL_LTDC_SetAddress(&hltdc, (uint32_t)framebuffer, LTDC_LAYER_1); + volatile uint32_t *externalRAM = (uint32_t *) 0xD0000000; + const uint32_t size = 1000; + + //write external RAM + // for(int i = 0; i < size; i++) + // { + // externalRAM[i] = i; + // } + // for(int i = 0; i < size; i++) + // { + // if (externalRAM[i] != i) { + // while (1) {} + // } + // } + uint8_t wdata[] = {0x1, 0x2, 0x3, 0x4, 0x5}; + uint8_t rdata[10]; + + memcpy((uint32_t *) 0xC0000000, wdata, 5); + + memcpy(rdata, (uint32_t *) 0xC0000000, 5); /* USER CODE END 2 */ /* Infinite loop */ @@ -165,7 +179,7 @@ void SystemClock_Config(void) /** Configure the main internal regulator output voltage */ - __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2); + __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0); while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {} @@ -177,11 +191,11 @@ void SystemClock_Config(void) RCC_OscInitStruct.HSI48State = RCC_HSI48_ON; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; - RCC_OscInitStruct.PLL.PLLM = 1; - RCC_OscInitStruct.PLL.PLLN = 20; + RCC_OscInitStruct.PLL.PLLM = 2; + RCC_OscInitStruct.PLL.PLLN = 70; RCC_OscInitStruct.PLL.PLLP = 2; RCC_OscInitStruct.PLL.PLLQ = 4; - RCC_OscInitStruct.PLL.PLLR = 2; + RCC_OscInitStruct.PLL.PLLR = 4; RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3; RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE; RCC_OscInitStruct.PLL.PLLFRACN = 0; @@ -203,34 +217,7 @@ void SystemClock_Config(void) RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2; RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2; - if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK) - { - Error_Handler(); - } -} - -/** - * @brief Peripherals Common Clock Configuration - * @retval None - */ -void PeriphCommonClock_Config(void) -{ - RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0}; - - /** Initializes the peripherals clock - */ - PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_FMC|RCC_PERIPHCLK_SDMMC; - PeriphClkInitStruct.PLL2.PLL2M = 1; - PeriphClkInitStruct.PLL2.PLL2N = 20; - PeriphClkInitStruct.PLL2.PLL2P = 2; - PeriphClkInitStruct.PLL2.PLL2Q = 4; - PeriphClkInitStruct.PLL2.PLL2R = 2; - PeriphClkInitStruct.PLL2.PLL2RGE = RCC_PLL2VCIRANGE_3; - PeriphClkInitStruct.PLL2.PLL2VCOSEL = RCC_PLL2VCOWIDE; - PeriphClkInitStruct.PLL2.PLL2FRACN = 0; - PeriphClkInitStruct.FmcClockSelection = RCC_FMCCLKSOURCE_PLL2; - PeriphClkInitStruct.SdmmcClockSelection = RCC_SDMMCCLKSOURCE_PLL2; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) + if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_6) != HAL_OK) { Error_Handler(); } @@ -336,7 +323,7 @@ static void MX_I2C4_Init(void) /* USER CODE END I2C4_Init 1 */ hi2c4.Instance = I2C4; - hi2c4.Init.Timing = 0x10909CEC; + hi2c4.Init.Timing = 0x20B0CCFF; hi2c4.Init.OwnAddress1 = 0; hi2c4.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c4.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; @@ -400,7 +387,7 @@ static void MX_LTDC_Init(void) hltdc.Init.TotalHeigh = 306; hltdc.Init.Backcolor.Blue = 0; hltdc.Init.Backcolor.Green = 0; - hltdc.Init.Backcolor.Red = 0; + hltdc.Init.Backcolor.Red = 255; if (HAL_LTDC_Init(&hltdc) != HAL_OK) { Error_Handler(); @@ -409,7 +396,7 @@ static void MX_LTDC_Init(void) pLayerCfg.WindowX1 = 480; pLayerCfg.WindowY0 = 0; pLayerCfg.WindowY1 = 272; - pLayerCfg.PixelFormat = LTDC_PIXEL_FORMAT_RGB565; + pLayerCfg.PixelFormat = LTDC_PIXEL_FORMAT_RGB888; pLayerCfg.Alpha = 1; pLayerCfg.Alpha0 = 0; pLayerCfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_CA; @@ -430,37 +417,6 @@ static void MX_LTDC_Init(void) } -/** - * @brief SDMMC2 Initialization Function - * @param None - * @retval None - */ -static void MX_SDMMC2_SD_Init(void) -{ - - /* USER CODE BEGIN SDMMC2_Init 0 */ - - /* USER CODE END SDMMC2_Init 0 */ - - /* USER CODE BEGIN SDMMC2_Init 1 */ - - /* USER CODE END SDMMC2_Init 1 */ - hsd2.Instance = SDMMC2; - hsd2.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING; - hsd2.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE; - hsd2.Init.BusWide = SDMMC_BUS_WIDE_1B; - hsd2.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE; - hsd2.Init.ClockDiv = 0; - if (HAL_SD_Init(&hsd2) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN SDMMC2_Init 2 */ - - /* USER CODE END SDMMC2_Init 2 */ - -} - /** * @brief UART5 Initialization Function * @param None @@ -618,16 +574,16 @@ static void MX_FMC_Init(void) hsdram1.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4; hsdram1.Init.CASLatency = FMC_SDRAM_CAS_LATENCY_3; hsdram1.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE; - hsdram1.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_2; + hsdram1.Init.SDClockPeriod = FMC_SDRAM_CLOCK_DISABLE; hsdram1.Init.ReadBurst = FMC_SDRAM_RBURST_DISABLE; hsdram1.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_1; /* SdramTiming */ SdramTiming.LoadToActiveDelay = 2; - SdramTiming.ExitSelfRefreshDelay = 5; - SdramTiming.SelfRefreshTime = 3; - SdramTiming.RowCycleDelay = 4; - SdramTiming.WriteRecoveryTime = 3; - SdramTiming.RPDelay = 3; + SdramTiming.ExitSelfRefreshDelay = 10; + SdramTiming.SelfRefreshTime = 6; + SdramTiming.RowCycleDelay = 8; + SdramTiming.WriteRecoveryTime = 4; + SdramTiming.RPDelay = 2; SdramTiming.RCDDelay = 2; if (HAL_SDRAM_Init(&hsdram1, &SdramTiming) != HAL_OK) @@ -636,7 +592,32 @@ static void MX_FMC_Init(void) } /* USER CODE BEGIN FMC_Init 2 */ - + FMC_SDRAM_CommandTypeDef Command; + /* Step 1 and Step 2 already done in HAL_SDRAM_Init() */ + /* Step 3: Configure a clock configuration enable command */ + Command.CommandMode = FMC_SDRAM_CMD_CLK_ENABLE; /* Set MODE bits to "001" */ + Command.CommandTarget = (FMC_SDRAM_CMD_TARGET_BANK1); /* configure the Target Bank bits */ + Command.AutoRefreshNumber = 1; + Command.ModeRegisterDefinition = 0; + HAL_SDRAM_SendCommand(&hsdram1, &Command, 0xfff); + HAL_Delay(1); /* Step 4: Insert 100 us minimum delay - Min HAL Delay is 1ms */ + /* Step 5: Configure a PALL (precharge all) command */ + Command.CommandMode = FMC_SDRAM_CMD_PALL; /* Set MODE bits to "010" */ + HAL_SDRAM_SendCommand(&hsdram1, &Command, 0xfff); + /* Step 6: Configure an Auto Refresh command */ + Command.CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE; /* Set MODE bits to "011" */ + Command.AutoRefreshNumber = 4; + HAL_SDRAM_SendCommand(&hsdram1, &Command, 0xfff); + /* Step 7: Program the external memory mode register */ + Command.CommandMode = FMC_SDRAM_CMD_LOAD_MODE;/*set the MODE bits to "100" */ + Command.ModeRegisterDefinition = (uint32_t)0 | 0<<3 | 2<<4 | 0<<7 | 1<<9; + Command.AutoRefreshNumber = 1; + HAL_SDRAM_SendCommand(&hsdram1, &Command, 0xfff); + /* Step 8: Set the refresh rate counter - refer to section SDRAM refresh timer register in RM0455 */ + /* Set the device refresh rate + * COUNT = [(SDRAM self refresh time / number of row) x SDRAM CLK] – 20 + = [(70ms/8138) * 200MHz] - 20 ~ 1700 */ + HAL_SDRAM_ProgramRefreshRate(&hsdram1, 1700); /* USER CODE END FMC_Init 2 */ } diff --git a/Software/Core/Src/stm32h7xx_hal_msp.c b/Software/Core/Src/stm32h7xx_hal_msp.c index 6cc5390..3b8291e 100644 --- a/Software/Core/Src/stm32h7xx_hal_msp.c +++ b/Software/Core/Src/stm32h7xx_hal_msp.c @@ -331,6 +331,7 @@ void HAL_LTDC_MspInit(LTDC_HandleTypeDef* hltdc) /**LTDC GPIO Configuration PF10 ------> LTDC_DE PC0 ------> LTDC_R5 + PA1 ------> LTDC_R2 PA3 ------> LTDC_B5 PA4 ------> LTDC_VSYNC PA5 ------> LTDC_R4 @@ -349,6 +350,7 @@ void HAL_LTDC_MspInit(LTDC_HandleTypeDef* hltdc) PA10 ------> LTDC_B4 PA15 ------> LTDC_B6 PD2 ------> LTDC_B7 + PD6 ------> LTDC_B2 */ GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; @@ -364,8 +366,8 @@ void HAL_LTDC_MspInit(LTDC_HandleTypeDef* hltdc) GPIO_InitStruct.Alternate = GPIO_AF14_LTDC; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); - GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6 - |GPIO_PIN_15; + GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5 + |GPIO_PIN_6|GPIO_PIN_15; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; @@ -421,6 +423,13 @@ void HAL_LTDC_MspInit(LTDC_HandleTypeDef* hltdc) GPIO_InitStruct.Alternate = GPIO_AF9_LTDC; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); + GPIO_InitStruct.Pin = GPIO_PIN_6; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF14_LTDC; + HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); + /* LTDC interrupt Init */ HAL_NVIC_SetPriority(LTDC_IRQn, 0, 0); HAL_NVIC_EnableIRQ(LTDC_IRQn); @@ -451,6 +460,7 @@ void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef* hltdc) /**LTDC GPIO Configuration PF10 ------> LTDC_DE PC0 ------> LTDC_R5 + PA1 ------> LTDC_R2 PA3 ------> LTDC_B5 PA4 ------> LTDC_VSYNC PA5 ------> LTDC_R4 @@ -469,21 +479,22 @@ void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef* hltdc) PA10 ------> LTDC_B4 PA15 ------> LTDC_B6 PD2 ------> LTDC_B7 + PD6 ------> LTDC_B2 */ HAL_GPIO_DeInit(GPIOF, GPIO_PIN_10); HAL_GPIO_DeInit(GPIOC, GPIO_PIN_0|GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_7 |GPIO_PIN_9); - HAL_GPIO_DeInit(GPIOA, GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6 - |GPIO_PIN_8|GPIO_PIN_10|GPIO_PIN_15); + HAL_GPIO_DeInit(GPIOA, GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5 + |GPIO_PIN_6|GPIO_PIN_8|GPIO_PIN_10|GPIO_PIN_15); HAL_GPIO_DeInit(GPIOB, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_10|GPIO_PIN_11 |GPIO_PIN_15); HAL_GPIO_DeInit(GPIOG, GPIO_PIN_7); - HAL_GPIO_DeInit(GPIOD, GPIO_PIN_2); + HAL_GPIO_DeInit(GPIOD, GPIO_PIN_2|GPIO_PIN_6); /* LTDC interrupt DeInit */ HAL_NVIC_DisableIRQ(LTDC_IRQn); @@ -494,94 +505,6 @@ void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef* hltdc) } -/** -* @brief SD MSP Initialization -* This function configures the hardware resources used in this example -* @param hsd: SD handle pointer -* @retval None -*/ -void HAL_SD_MspInit(SD_HandleTypeDef* hsd) -{ - GPIO_InitTypeDef GPIO_InitStruct = {0}; - if(hsd->Instance==SDMMC2) - { - /* USER CODE BEGIN SDMMC2_MspInit 0 */ - - /* USER CODE END SDMMC2_MspInit 0 */ - /* Peripheral clock enable */ - __HAL_RCC_SDMMC2_CLK_ENABLE(); - - __HAL_RCC_GPIOC_CLK_ENABLE(); - __HAL_RCC_GPIOB_CLK_ENABLE(); - __HAL_RCC_GPIOD_CLK_ENABLE(); - /**SDMMC2 GPIO Configuration - PC1 ------> SDMMC2_CK - PB14 ------> SDMMC2_D0 - PD7 ------> SDMMC2_CMD - */ - GPIO_InitStruct.Pin = GPIO_PIN_1; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - GPIO_InitStruct.Alternate = GPIO_AF9_SDMMC2; - HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = GPIO_PIN_14; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - GPIO_InitStruct.Alternate = GPIO_AF9_SDMMC2; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = GPIO_PIN_7; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - GPIO_InitStruct.Alternate = GPIO_AF11_SDMMC2; - HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); - - /* USER CODE BEGIN SDMMC2_MspInit 1 */ - - /* USER CODE END SDMMC2_MspInit 1 */ - - } - -} - -/** -* @brief SD MSP De-Initialization -* This function freeze the hardware resources used in this example -* @param hsd: SD handle pointer -* @retval None -*/ -void HAL_SD_MspDeInit(SD_HandleTypeDef* hsd) -{ - if(hsd->Instance==SDMMC2) - { - /* USER CODE BEGIN SDMMC2_MspDeInit 0 */ - - /* USER CODE END SDMMC2_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_SDMMC2_CLK_DISABLE(); - - /**SDMMC2 GPIO Configuration - PC1 ------> SDMMC2_CK - PB14 ------> SDMMC2_D0 - PD7 ------> SDMMC2_CMD - */ - HAL_GPIO_DeInit(GPIOC, GPIO_PIN_1); - - HAL_GPIO_DeInit(GPIOB, GPIO_PIN_14); - - HAL_GPIO_DeInit(GPIOD, GPIO_PIN_7); - - /* USER CODE BEGIN SDMMC2_MspDeInit 1 */ - - /* USER CODE END SDMMC2_MspDeInit 1 */ - } - -} - /** * @brief UART MSP Initialization * This function configures the hardware resources used in this example @@ -807,6 +730,23 @@ static void HAL_FMC_MspInit(void){ return; } FMC_Initialized = 1; + RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0}; + + /** Initializes the peripherals clock + */ + PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_FMC; + PeriphClkInitStruct.PLL2.PLL2M = 2; + PeriphClkInitStruct.PLL2.PLL2N = 70; + PeriphClkInitStruct.PLL2.PLL2P = 2; + PeriphClkInitStruct.PLL2.PLL2Q = 4; + PeriphClkInitStruct.PLL2.PLL2R = 2; + PeriphClkInitStruct.PLL2.PLL2RGE = RCC_PLL2VCIRANGE_3; + PeriphClkInitStruct.PLL2.PLL2VCOSEL = RCC_PLL2VCOWIDE; + PeriphClkInitStruct.FmcClockSelection = RCC_FMCCLKSOURCE_PLL2; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) + { + Error_Handler(); + } /* Peripheral clock enable */ __HAL_RCC_FMC_CLK_ENABLE(); diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc.h b/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc.h deleted file mode 100644 index 3b242ba..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc.h +++ /dev/null @@ -1,877 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_mmc.h - * @author MCD Application Team - * @brief Header file of MMC HAL module. - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - */ - -/* Define to prevent recursive inclusion -------------------------------------*/ -#ifndef STM32H7xx_HAL_MMC_H -#define STM32H7xx_HAL_MMC_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_ll_sdmmc.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ -#if defined (SDMMC1) || defined (SDMMC2) - -/** @addtogroup MMC - * @{ - */ - -/* Exported types ------------------------------------------------------------*/ -/** @defgroup MMC_Exported_Types MMC Exported Types - * @{ - */ - -/** @defgroup MMC_Exported_Types_Group1 MMC State enumeration structure - * @{ - */ -typedef enum -{ - HAL_MMC_STATE_RESET = ((uint32_t)0x00000000U), /*!< MMC not yet initialized or disabled */ - HAL_MMC_STATE_READY = ((uint32_t)0x00000001U), /*!< MMC initialized and ready for use */ - HAL_MMC_STATE_TIMEOUT = ((uint32_t)0x00000002U), /*!< MMC Timeout state */ - HAL_MMC_STATE_BUSY = ((uint32_t)0x00000003U), /*!< MMC process ongoing */ - HAL_MMC_STATE_PROGRAMMING = ((uint32_t)0x00000004U), /*!< MMC Programming State */ - HAL_MMC_STATE_RECEIVING = ((uint32_t)0x00000005U), /*!< MMC Receinving State */ - HAL_MMC_STATE_TRANSFER = ((uint32_t)0x00000006U), /*!< MMC Transfer State */ - HAL_MMC_STATE_ERROR = ((uint32_t)0x0000000FU) /*!< MMC is in error state */ -} HAL_MMC_StateTypeDef; -/** - * @} - */ - -/** @defgroup MMC_Exported_Types_Group2 MMC Card State enumeration structure - * @{ - */ -typedef uint32_t HAL_MMC_CardStateTypeDef; - -#define HAL_MMC_CARD_IDLE 0x00000000U /*!< Card is in idle state (can't be checked by CMD13) */ -#define HAL_MMC_CARD_READY 0x00000001U /*!< Card state is ready (can't be checked by CMD13) */ -#define HAL_MMC_CARD_IDENTIFICATION 0x00000002U /*!< Card is in identification state (can't be checked by CMD13) */ -#define HAL_MMC_CARD_STANDBY 0x00000003U /*!< Card is in standby state */ -#define HAL_MMC_CARD_TRANSFER 0x00000004U /*!< Card is in transfer state */ -#define HAL_MMC_CARD_SENDING 0x00000005U /*!< Card is sending an operation */ -#define HAL_MMC_CARD_RECEIVING 0x00000006U /*!< Card is receiving operation information */ -#define HAL_MMC_CARD_PROGRAMMING 0x00000007U /*!< Card is in programming state */ -#define HAL_MMC_CARD_DISCONNECTED 0x00000008U /*!< Card is disconnected */ -#define HAL_MMC_CARD_BUSTEST 0x00000009U /*!< Card is in bus test state */ -#define HAL_MMC_CARD_SLEEP 0x0000000AU /*!< Card is in sleep state (can't be checked by CMD13) */ -#define HAL_MMC_CARD_ERROR 0x000000FFU /*!< Card response Error (can't be checked by CMD13) */ -/** - * @} - */ - -/** @defgroup MMC_Exported_Types_Group3 MMC Handle Structure definition - * @{ - */ -#define MMC_InitTypeDef SDMMC_InitTypeDef -#define MMC_TypeDef SDMMC_TypeDef - -/** - * @brief MMC Card Information Structure definition - */ -typedef struct -{ - uint32_t CardType; /*!< Specifies the card Type */ - - uint32_t Class; /*!< Specifies the class of the card class */ - - uint32_t RelCardAdd; /*!< Specifies the Relative Card Address */ - - uint32_t BlockNbr; /*!< Specifies the Card Capacity in blocks */ - - uint32_t BlockSize; /*!< Specifies one block size in bytes */ - - uint32_t LogBlockNbr; /*!< Specifies the Card logical Capacity in blocks */ - - uint32_t LogBlockSize; /*!< Specifies logical block size in bytes */ - -} HAL_MMC_CardInfoTypeDef; - -/** - * @brief MMC handle Structure definition - */ -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) -typedef struct __MMC_HandleTypeDef -#else -typedef struct -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ -{ - MMC_TypeDef *Instance; /*!< MMC registers base address */ - - MMC_InitTypeDef Init; /*!< MMC required parameters */ - - HAL_LockTypeDef Lock; /*!< MMC locking object */ - - const uint8_t *pTxBuffPtr; /*!< Pointer to MMC Tx transfer Buffer */ - - uint32_t TxXferSize; /*!< MMC Tx Transfer size */ - - uint8_t *pRxBuffPtr; /*!< Pointer to MMC Rx transfer Buffer */ - - uint32_t RxXferSize; /*!< MMC Rx Transfer size */ - - __IO uint32_t Context; /*!< MMC transfer context */ - - __IO HAL_MMC_StateTypeDef State; /*!< MMC card State */ - - __IO uint32_t ErrorCode; /*!< MMC Card Error codes */ - - __IO uint16_t RPMBErrorCode; /*!< MMC RPMB Area Error codes */ - - HAL_MMC_CardInfoTypeDef MmcCard; /*!< MMC Card information */ - - uint32_t CSD[4U]; /*!< MMC card specific data table */ - - uint32_t CID[4U]; /*!< MMC card identification number table */ - - uint32_t Ext_CSD[128]; - -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - void (* TxCpltCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* RxCpltCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* ErrorCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* AbortCpltCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* Read_DMADblBuf0CpltCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* Read_DMADblBuf1CpltCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* Write_DMADblBuf0CpltCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* Write_DMADblBuf1CpltCallback)(struct __MMC_HandleTypeDef *hmmc); - - void (* MspInitCallback)(struct __MMC_HandleTypeDef *hmmc); - void (* MspDeInitCallback)(struct __MMC_HandleTypeDef *hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ -} MMC_HandleTypeDef; - - -/** - * @} - */ - -/** @defgroup MMC_Exported_Types_Group4 Card Specific Data: CSD Register - * @{ - */ -typedef struct -{ - __IO uint8_t CSDStruct; /*!< CSD structure */ - __IO uint8_t SysSpecVersion; /*!< System specification version */ - __IO uint8_t Reserved1; /*!< Reserved */ - __IO uint8_t TAAC; /*!< Data read access time 1 */ - __IO uint8_t NSAC; /*!< Data read access time 2 in CLK cycles */ - __IO uint8_t MaxBusClkFrec; /*!< Max. bus clock frequency */ - __IO uint16_t CardComdClasses; /*!< Card command classes */ - __IO uint8_t RdBlockLen; /*!< Max. read data block length */ - __IO uint8_t PartBlockRead; /*!< Partial blocks for read allowed */ - __IO uint8_t WrBlockMisalign; /*!< Write block misalignment */ - __IO uint8_t RdBlockMisalign; /*!< Read block misalignment */ - __IO uint8_t DSRImpl; /*!< DSR implemented */ - __IO uint8_t Reserved2; /*!< Reserved */ - __IO uint32_t DeviceSize; /*!< Device Size */ - __IO uint8_t MaxRdCurrentVDDMin; /*!< Max. read current @ VDD min */ - __IO uint8_t MaxRdCurrentVDDMax; /*!< Max. read current @ VDD max */ - __IO uint8_t MaxWrCurrentVDDMin; /*!< Max. write current @ VDD min */ - __IO uint8_t MaxWrCurrentVDDMax; /*!< Max. write current @ VDD max */ - __IO uint8_t DeviceSizeMul; /*!< Device size multiplier */ - __IO uint8_t EraseGrSize; /*!< Erase group size */ - __IO uint8_t EraseGrMul; /*!< Erase group size multiplier */ - __IO uint8_t WrProtectGrSize; /*!< Write protect group size */ - __IO uint8_t WrProtectGrEnable; /*!< Write protect group enable */ - __IO uint8_t ManDeflECC; /*!< Manufacturer default ECC */ - __IO uint8_t WrSpeedFact; /*!< Write speed factor */ - __IO uint8_t MaxWrBlockLen; /*!< Max. write data block length */ - __IO uint8_t WriteBlockPaPartial; /*!< Partial blocks for write allowed */ - __IO uint8_t Reserved3; /*!< Reserved */ - __IO uint8_t ContentProtectAppli; /*!< Content protection application */ - __IO uint8_t FileFormatGroup; /*!< File format group */ - __IO uint8_t CopyFlag; /*!< Copy flag (OTP) */ - __IO uint8_t PermWrProtect; /*!< Permanent write protection */ - __IO uint8_t TempWrProtect; /*!< Temporary write protection */ - __IO uint8_t FileFormat; /*!< File format */ - __IO uint8_t ECC; /*!< ECC code */ - __IO uint8_t CSD_CRC; /*!< CSD CRC */ - __IO uint8_t Reserved4; /*!< Always 1 */ - -} HAL_MMC_CardCSDTypeDef; -/** - * @} - */ - -/** @defgroup MMC_Exported_Types_Group5 Card Identification Data: CID Register - * @{ - */ -typedef struct -{ - __IO uint8_t ManufacturerID; /*!< Manufacturer ID */ - __IO uint16_t OEM_AppliID; /*!< OEM/Application ID */ - __IO uint32_t ProdName1; /*!< Product Name part1 */ - __IO uint8_t ProdName2; /*!< Product Name part2 */ - __IO uint8_t ProdRev; /*!< Product Revision */ - __IO uint32_t ProdSN; /*!< Product Serial Number */ - __IO uint8_t Reserved1; /*!< Reserved1 */ - __IO uint16_t ManufactDate; /*!< Manufacturing Date */ - __IO uint8_t CID_CRC; /*!< CID CRC */ - __IO uint8_t Reserved2; /*!< Always 1 */ - -} HAL_MMC_CardCIDTypeDef; -/** - * @} - */ - -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) -/** @defgroup MMC_Exported_Types_Group6 MMC Callback ID enumeration definition - * @{ - */ -typedef enum -{ - HAL_MMC_TX_CPLT_CB_ID = 0x00U, /*!< MMC Tx Complete Callback ID */ - HAL_MMC_RX_CPLT_CB_ID = 0x01U, /*!< MMC Rx Complete Callback ID */ - HAL_MMC_ERROR_CB_ID = 0x02U, /*!< MMC Error Callback ID */ - HAL_MMC_ABORT_CB_ID = 0x03U, /*!< MMC Abort Callback ID */ - HAL_MMC_READ_DMA_DBL_BUF0_CPLT_CB_ID = 0x04U, /*!< MMC Rx DMA Double Buffer 0 Complete Callback ID */ - HAL_MMC_READ_DMA_DBL_BUF1_CPLT_CB_ID = 0x05U, /*!< MMC Rx DMA Double Buffer 1 Complete Callback ID */ - HAL_MMC_WRITE_DMA_DBL_BUF0_CPLT_CB_ID = 0x06U, /*!< MMC Tx DMA Double Buffer 0 Complete Callback ID */ - HAL_MMC_WRITE_DMA_DBL_BUF1_CPLT_CB_ID = 0x07U, /*!< MMC Tx DMA Double Buffer 1 Complete Callback ID */ - - HAL_MMC_MSP_INIT_CB_ID = 0x10U, /*!< MMC MspInit Callback ID */ - HAL_MMC_MSP_DEINIT_CB_ID = 0x11U /*!< MMC MspDeInit Callback ID */ -} HAL_MMC_CallbackIDTypeDef; -/** - * @} - */ - -/** @defgroup MMC_Exported_Types_Group7 MMC Callback pointer definition - * @{ - */ -typedef void (*pMMC_CallbackTypeDef)(MMC_HandleTypeDef *hmmc); -/** - * @} - */ -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ -/** - * @} - */ - -/* Exported constants --------------------------------------------------------*/ -/** @defgroup MMC_Exported_Constants Exported Constants - * @{ - */ - -#define MMC_BLOCKSIZE ((uint32_t)512U) /*!< Block size is 512 bytes */ - -/** @defgroup MMC_Exported_Constansts_Group1 MMC Error status enumeration Structure definition - * @{ - */ -#define HAL_MMC_ERROR_NONE SDMMC_ERROR_NONE /*!< No error */ -#define HAL_MMC_ERROR_CMD_CRC_FAIL SDMMC_ERROR_CMD_CRC_FAIL /*!< Command response received (but CRC check failed) */ -#define HAL_MMC_ERROR_DATA_CRC_FAIL SDMMC_ERROR_DATA_CRC_FAIL /*!< Data block sent/received (CRC check failed) */ -#define HAL_MMC_ERROR_CMD_RSP_TIMEOUT SDMMC_ERROR_CMD_RSP_TIMEOUT /*!< Command response timeout */ -#define HAL_MMC_ERROR_DATA_TIMEOUT SDMMC_ERROR_DATA_TIMEOUT /*!< Data timeout */ -#define HAL_MMC_ERROR_TX_UNDERRUN SDMMC_ERROR_TX_UNDERRUN /*!< Transmit FIFO underrun */ -#define HAL_MMC_ERROR_RX_OVERRUN SDMMC_ERROR_RX_OVERRUN /*!< Receive FIFO overrun */ -#define HAL_MMC_ERROR_ADDR_MISALIGNED SDMMC_ERROR_ADDR_MISALIGNED /*!< Misaligned address */ -#define HAL_MMC_ERROR_BLOCK_LEN_ERR SDMMC_ERROR_BLOCK_LEN_ERR /*!< Transferred block length is not allowed for the card or the */ -/*!< number of transferred bytes does not match the block length */ -#define HAL_MMC_ERROR_ERASE_SEQ_ERR SDMMC_ERROR_ERASE_SEQ_ERR /*!< An error in the sequence of erase command occurs */ -#define HAL_MMC_ERROR_BAD_ERASE_PARAM SDMMC_ERROR_BAD_ERASE_PARAM /*!< An invalid selection for erase groups */ -#define HAL_MMC_ERROR_WRITE_PROT_VIOLATION SDMMC_ERROR_WRITE_PROT_VIOLATION /*!< Attempt to program a write protect block */ -#define HAL_MMC_ERROR_LOCK_UNLOCK_FAILED SDMMC_ERROR_LOCK_UNLOCK_FAILED /*!< Sequence or password error has been detected in unlock */ -/*!< command or if there was an attempt to access a locked card */ -#define HAL_MMC_ERROR_COM_CRC_FAILED SDMMC_ERROR_COM_CRC_FAILED /*!< CRC check of the previous command failed */ -#define HAL_MMC_ERROR_ILLEGAL_CMD SDMMC_ERROR_ILLEGAL_CMD /*!< Command is not legal for the card state */ -#define HAL_MMC_ERROR_CARD_ECC_FAILED SDMMC_ERROR_CARD_ECC_FAILED /*!< Card internal ECC was applied but failed to correct the data */ -#define HAL_MMC_ERROR_CC_ERR SDMMC_ERROR_CC_ERR /*!< Internal card controller error */ -#define HAL_MMC_ERROR_GENERAL_UNKNOWN_ERR SDMMC_ERROR_GENERAL_UNKNOWN_ERR /*!< General or unknown error */ -#define HAL_MMC_ERROR_STREAM_READ_UNDERRUN SDMMC_ERROR_STREAM_READ_UNDERRUN /*!< The card could not sustain data reading in stream rmode */ -#define HAL_MMC_ERROR_STREAM_WRITE_OVERRUN SDMMC_ERROR_STREAM_WRITE_OVERRUN /*!< The card could not sustain data programming in stream mode */ -#define HAL_MMC_ERROR_CID_CSD_OVERWRITE SDMMC_ERROR_CID_CSD_OVERWRITE /*!< CID/CSD overwrite error */ -#define HAL_MMC_ERROR_WP_ERASE_SKIP SDMMC_ERROR_WP_ERASE_SKIP /*!< Only partial address space was erased */ -#define HAL_MMC_ERROR_CARD_ECC_DISABLED SDMMC_ERROR_CARD_ECC_DISABLED /*!< Command has been executed without using internal ECC */ -#define HAL_MMC_ERROR_ERASE_RESET SDMMC_ERROR_ERASE_RESET /*!< Erase sequence was cleared before executing because an out */ -/*!< of erase sequence command was received */ -#define HAL_MMC_ERROR_AKE_SEQ_ERR SDMMC_ERROR_AKE_SEQ_ERR /*!< Error in sequence of authentication */ -#define HAL_MMC_ERROR_INVALID_VOLTRANGE SDMMC_ERROR_INVALID_VOLTRANGE /*!< Error in case of invalid voltage range */ -#define HAL_MMC_ERROR_ADDR_OUT_OF_RANGE SDMMC_ERROR_ADDR_OUT_OF_RANGE /*!< Error when addressed block is out of range */ -#define HAL_MMC_ERROR_REQUEST_NOT_APPLICABLE SDMMC_ERROR_REQUEST_NOT_APPLICABLE /*!< Error when command request is not applicable */ -#define HAL_MMC_ERROR_PARAM SDMMC_ERROR_INVALID_PARAMETER /*!< the used parameter is not valid */ -#define HAL_MMC_ERROR_UNSUPPORTED_FEATURE SDMMC_ERROR_UNSUPPORTED_FEATURE /*!< Error when feature is not insupported */ -#define HAL_MMC_ERROR_BUSY SDMMC_ERROR_BUSY /*!< Error when transfer process is busy */ -#define HAL_MMC_ERROR_DMA SDMMC_ERROR_DMA /*!< Error while DMA transfer */ -#define HAL_MMC_ERROR_TIMEOUT SDMMC_ERROR_TIMEOUT /*!< Timeout error */ -/*!< response results after operating with RPMB partition */ -#define HAL_MMC_ERROR_RPMB_OPERATION_OK 0x0000U /*!< Operation OK */ -#define HAL_MMC_ERROR_RPMB_GENERAL_FAILURE 0x0001U /*!< General failure */ -#define HAL_MMC_ERROR_RPMB_AUTHENTICATION_FAILURE 0x0002U /*!< Authentication failure */ -#define HAL_MMC_ERROR_RPMB_COUNTER_FAILURE 0x0003U /*!< Counter failure */ -#define HAL_MMC_ERROR_RPMB_ADDRESS_FAILURE 0x0004U /*!< Address failure */ -#define HAL_MMC_ERROR_RPMB_WRITE_FAILURE 0x0005U /*!< Write failure */ -#define HAL_MMC_ERROR_RPMB_READ_FAILURE 0x0006U /*!< Read failure */ -#define HAL_MMC_ERROR_RPMB_KEY_NOT_YET_PROG 0x0007U /*!< Authentication Key not yet programmed */ -#define HAL_MMC_ERROR_RPMB_COUNTER_EXPIRED 0x0080U /*!< Write Counter has expired i.e. reached its max value */ - -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) -#define HAL_MMC_ERROR_INVALID_CALLBACK SDMMC_ERROR_INVALID_PARAMETER /*!< Invalid callback error */ -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ -/** - * @} - */ - -/** @defgroup MMC_Exported_Constansts_Group2 MMC context enumeration - * @{ - */ -#define MMC_CONTEXT_NONE ((uint32_t)0x00000000U) /*!< None */ -#define MMC_CONTEXT_READ_SINGLE_BLOCK ((uint32_t)0x00000001U) /*!< Read single block operation */ -#define MMC_CONTEXT_READ_MULTIPLE_BLOCK ((uint32_t)0x00000002U) /*!< Read multiple blocks operation */ -#define MMC_CONTEXT_WRITE_SINGLE_BLOCK ((uint32_t)0x00000010U) /*!< Write single block operation */ -#define MMC_CONTEXT_WRITE_MULTIPLE_BLOCK ((uint32_t)0x00000020U) /*!< Write multiple blocks operation */ -#define MMC_CONTEXT_IT ((uint32_t)0x00000008U) /*!< Process in Interrupt mode */ -#define MMC_CONTEXT_DMA ((uint32_t)0x00000080U) /*!< Process in DMA mode */ - -/** - * @} - */ - -/** @defgroup MMC_Exported_Constansts_Group3 MMC Voltage mode - * @{ - */ -/** - * @brief - */ -#define MMC_HIGH_VOLTAGE_RANGE 0x80FF8000U /*!< High voltage in byte mode */ -#define MMC_DUAL_VOLTAGE_RANGE 0x80FF8080U /*!< Dual voltage in byte mode */ -#define MMC_LOW_VOLTAGE_RANGE 0x80000080U /*!< Low voltage in byte mode */ -#define EMMC_HIGH_VOLTAGE_RANGE 0xC0FF8000U /*!< High voltage in sector mode */ -#define EMMC_DUAL_VOLTAGE_RANGE 0xC0FF8080U /*!< Dual voltage in sector mode */ -#define EMMC_LOW_VOLTAGE_RANGE 0xC0000080U /*!< Low voltage in sector mode */ -#define MMC_INVALID_VOLTAGE_RANGE 0x0001FF01U -/** - * @} - */ - -/** @defgroup MMC_Exported_Constansts_Group4 MMC Memory Cards - * @{ - */ -#define MMC_LOW_CAPACITY_CARD ((uint32_t)0x00000000U) /*!< MMC Card Capacity <=2Gbytes */ -#define MMC_HIGH_CAPACITY_CARD ((uint32_t)0x00000001U) /*!< MMC Card Capacity >2Gbytes and <2Tbytes */ - -/** - * @} - */ - -/** @defgroup MMC_Exported_Constansts_Group5 MMC Erase Type - * @{ - */ -#define HAL_MMC_ERASE 0x00000000U /*!< Erase the erase groups identified by CMD35 & 36 */ -#define HAL_MMC_TRIM 0x00000001U /*!< Erase the write blocks identified by CMD35 & 36 */ -#define HAL_MMC_DISCARD 0x00000003U /*!< Discard the write blocks identified by CMD35 & 36 */ -#define HAL_MMC_SECURE_ERASE 0x80000000U /*!< Perform a secure purge according SRT on the erase groups identified by CMD35 & 36 */ -#define HAL_MMC_SECURE_TRIM_STEP1 0x80000001U /*!< Mark the write blocks identified by CMD35 & 36 for secure erase */ -#define HAL_MMC_SECURE_TRIM_STEP2 0x80008000U /*!< Perform a secure purge according SRT on the write blocks previously identified */ - -#define IS_MMC_ERASE_TYPE(TYPE) (((TYPE) == HAL_MMC_ERASE) || \ - ((TYPE) == HAL_MMC_TRIM) || \ - ((TYPE) == HAL_MMC_DISCARD) || \ - ((TYPE) == HAL_MMC_SECURE_ERASE) || \ - ((TYPE) == HAL_MMC_SECURE_TRIM_STEP1) || \ - ((TYPE) == HAL_MMC_SECURE_TRIM_STEP2)) -/** - * @} - */ - -/** @defgroup MMC_Exported_Constansts_Group6 MMC Secure Removal Type - * @{ - */ -#define HAL_MMC_SRT_ERASE 0x00000001U /*!< Information removed by an erase */ -#define HAL_MMC_SRT_WRITE_CHAR_ERASE 0x00000002U /*!< Information removed by an overwriting with a character followed by an erase */ -#define HAL_MMC_SRT_WRITE_CHAR_COMPL_RANDOM 0x00000004U /*!< Information removed by an overwriting with a character, its complement then a random character */ -#define HAL_MMC_SRT_VENDOR_DEFINED 0x00000008U /*!< Information removed using a vendor defined */ - - -#define IS_MMC_SRT_TYPE(TYPE) (((TYPE) == HAL_MMC_SRT_ERASE) || \ - ((TYPE) == HAL_MMC_SRT_WRITE_CHAR_ERASE) || \ - ((TYPE) == HAL_MMC_SRT_WRITE_CHAR_COMPL_RANDOM) || \ - ((TYPE) == HAL_MMC_SRT_VENDOR_DEFINED)) -/** - * @} - */ - -/** @defgroup MMC_Exported_Constansts_Group7 MMC Partitions types - * @{ - */ -typedef uint32_t HAL_MMC_PartitionTypeDef; - -#define HAL_MMC_USER_AREA_PARTITION 0x00000000U /*!< User area partition */ -#define HAL_MMC_BOOT_PARTITION1 0x00000100U /*!< Boot partition 1 */ -#define HAL_MMC_BOOT_PARTITION2 0x00000200U /*!< Boot partition 2 */ -#define HAL_MMC_RPMB_PARTITION 0x00000300U /*!< RPMB partition */ -/** - * @} - */ - -/** - * @} - */ - -/* Exported macro ------------------------------------------------------------*/ -/** @defgroup MMC_Exported_macros MMC Exported Macros - * @brief macros to handle interrupts and specific clock configurations - * @{ - */ -/** @brief Reset MMC handle state. - * @param __HANDLE__ MMC Handle. - * @retval None - */ -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) -#define __HAL_MMC_RESET_HANDLE_STATE(__HANDLE__) do { \ - (__HANDLE__)->State = HAL_MMC_STATE_RESET; \ - (__HANDLE__)->MspInitCallback = NULL; \ - (__HANDLE__)->MspDeInitCallback = NULL; \ - } while(0) -#else -#define __HAL_MMC_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_MMC_STATE_RESET) -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - -/** - * @brief Enable the MMC device interrupt. - * @param __HANDLE__ MMC Handle. - * @param __INTERRUPT__ specifies the SDMMC interrupt sources to be enabled. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SD I/O interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __HAL_MMC_ENABLE_IT(__HANDLE__, __INTERRUPT__) __SDMMC_ENABLE_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @brief Disable the MMC device interrupt. - * @param __HANDLE__ MMC Handle. - * @param __INTERRUPT__ specifies the SDMMC interrupt sources to be disabled. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SD I/O interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __HAL_MMC_DISABLE_IT(__HANDLE__, __INTERRUPT__) __SDMMC_DISABLE_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @brief Check whether the specified MMC flag is set or not. - * @param __HANDLE__ MMC Handle. - * @param __FLAG__ specifies the flag to check. - * This parameter can be one of the following values: - * @arg SDMMC_FLAG_CCRCFAIL: Command response received (CRC check failed) - * @arg SDMMC_FLAG_DCRCFAIL: Data block sent/received (CRC check failed) - * @arg SDMMC_FLAG_CTIMEOUT: Command response timeout - * @arg SDMMC_FLAG_DTIMEOUT: Data timeout - * @arg SDMMC_FLAG_TXUNDERR: Transmit FIFO underrun error - * @arg SDMMC_FLAG_RXOVERR: Received FIFO overrun error - * @arg SDMMC_FLAG_CMDREND: Command response received (CRC check passed) - * @arg SDMMC_FLAG_CMDSENT: Command sent (no response required) - * @arg SDMMC_FLAG_DATAEND: Data end (data counter, DATACOUNT, is zero) - * @arg SDMMC_FLAG_DHOLD: Data transfer Hold - * @arg SDMMC_FLAG_DBCKEND: Data block sent/received (CRC check passed) - * @arg SDMMC_FLAG_DABORT: Data transfer aborted by CMD12 - * @arg SDMMC_FLAG_DPSMACT: Data path state machine active - * @arg SDMMC_FLAG_CPSMACT: Command path state machine active - * @arg SDMMC_FLAG_TXFIFOHE: Transmit FIFO Half Empty - * @arg SDMMC_FLAG_RXFIFOHF: Receive FIFO Half Full - * @arg SDMMC_FLAG_TXFIFOF: Transmit FIFO full - * @arg SDMMC_FLAG_RXFIFOF: Receive FIFO full - * @arg SDMMC_FLAG_TXFIFOE: Transmit FIFO empty - * @arg SDMMC_FLAG_RXFIFOE: Receive FIFO empty - * @arg SDMMC_FLAG_BUSYD0: Inverted value of SDMMC_D0 line (Busy) - * @arg SDMMC_FLAG_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected - * @arg SDMMC_FLAG_SDIOIT: SD I/O interrupt received - * @arg SDMMC_FLAG_ACKFAIL: Boot Acknowledgment received - * @arg SDMMC_FLAG_ACKTIMEOUT: Boot Acknowledgment timeout - * @arg SDMMC_FLAG_VSWEND: Voltage switch critical timing section completion - * @arg SDMMC_FLAG_CKSTOP: SDMMC_CK stopped in Voltage switch procedure - * @arg SDMMC_FLAG_IDMATE: IDMA transfer error - * @arg SDMMC_FLAG_IDMABTC: IDMA buffer transfer complete - * @retval The new state of MMC FLAG (SET or RESET). - */ -#define __HAL_MMC_GET_FLAG(__HANDLE__, __FLAG__) __SDMMC_GET_FLAG((__HANDLE__)->Instance, (__FLAG__)) - -/** - * @brief Clear the MMC's pending flags. - * @param __HANDLE__ MMC Handle. - * @param __FLAG__ specifies the flag to clear. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_FLAG_CCRCFAIL: Command response received (CRC check failed) - * @arg SDMMC_FLAG_DCRCFAIL: Data block sent/received (CRC check failed) - * @arg SDMMC_FLAG_CTIMEOUT: Command response timeout - * @arg SDMMC_FLAG_DTIMEOUT: Data timeout - * @arg SDMMC_FLAG_TXUNDERR: Transmit FIFO underrun error - * @arg SDMMC_FLAG_RXOVERR: Received FIFO overrun error - * @arg SDMMC_FLAG_CMDREND: Command response received (CRC check passed) - * @arg SDMMC_FLAG_CMDSENT: Command sent (no response required) - * @arg SDMMC_FLAG_DATAEND: Data end (data counter, DATACOUNT, is zero) - * @arg SDMMC_FLAG_DHOLD: Data transfer Hold - * @arg SDMMC_FLAG_DBCKEND: Data block sent/received (CRC check passed) - * @arg SDMMC_FLAG_DABORT: Data transfer aborted by CMD12 - * @arg SDMMC_FLAG_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected - * @arg SDMMC_FLAG_SDIOIT: SD I/O interrupt received - * @arg SDMMC_FLAG_ACKFAIL: Boot Acknowledgment received - * @arg SDMMC_FLAG_ACKTIMEOUT: Boot Acknowledgment timeout - * @arg SDMMC_FLAG_VSWEND: Voltage switch critical timing section completion - * @arg SDMMC_FLAG_CKSTOP: SDMMC_CK stopped in Voltage switch procedure - * @arg SDMMC_FLAG_IDMATE: IDMA transfer error - * @arg SDMMC_FLAG_IDMABTC: IDMA buffer transfer complete - * @retval None - */ -#define __HAL_MMC_CLEAR_FLAG(__HANDLE__, __FLAG__) __SDMMC_CLEAR_FLAG((__HANDLE__)->Instance, (__FLAG__)) - -/** - * @brief Check whether the specified MMC interrupt has occurred or not. - * @param __HANDLE__ MMC Handle. - * @param __INTERRUPT__ specifies the SDMMC interrupt source to check. - * This parameter can be one of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SD I/O interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval The new state of MMC IT (SET or RESET). - */ -#define __HAL_MMC_GET_IT(__HANDLE__, __INTERRUPT__) __SDMMC_GET_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @brief Clear the MMC's interrupt pending bits. - * @param __HANDLE__ MMC Handle. - * @param __INTERRUPT__ specifies the interrupt pending bit to clear. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SD I/O interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __HAL_MMC_CLEAR_IT(__HANDLE__, __INTERRUPT__) __SDMMC_CLEAR_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @} - */ - -/* Include MMC HAL Extension module */ -#include "stm32h7xx_hal_mmc_ex.h" - -/* Exported functions --------------------------------------------------------*/ -/** @defgroup MMC_Exported_Functions MMC Exported Functions - * @{ - */ - -/** @defgroup MMC_Exported_Functions_Group1 Initialization and de-initialization functions - * @{ - */ -HAL_StatusTypeDef HAL_MMC_Init(MMC_HandleTypeDef *hmmc); -HAL_StatusTypeDef HAL_MMC_InitCard(MMC_HandleTypeDef *hmmc); -HAL_StatusTypeDef HAL_MMC_DeInit(MMC_HandleTypeDef *hmmc); -void HAL_MMC_MspInit(MMC_HandleTypeDef *hmmc); -void HAL_MMC_MspDeInit(MMC_HandleTypeDef *hmmc); - -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group2 Input and Output operation functions - * @{ - */ -/* Blocking mode: Polling */ -HAL_StatusTypeDef HAL_MMC_ReadBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks, - uint32_t Timeout); -HAL_StatusTypeDef HAL_MMC_WriteBlocks(MMC_HandleTypeDef *hmmc, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks, uint32_t Timeout); -HAL_StatusTypeDef HAL_MMC_Erase(MMC_HandleTypeDef *hmmc, uint32_t BlockStartAdd, uint32_t BlockEndAdd); -/* Non-Blocking mode: IT */ -HAL_StatusTypeDef HAL_MMC_ReadBlocks_IT(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_MMC_WriteBlocks_IT(MMC_HandleTypeDef *hmmc, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -/* Non-Blocking mode: DMA */ -HAL_StatusTypeDef HAL_MMC_ReadBlocks_DMA(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_MMC_WriteBlocks_DMA(MMC_HandleTypeDef *hmmc, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); - -void HAL_MMC_IRQHandler(MMC_HandleTypeDef *hmmc); - -/* Callback in non blocking modes (DMA) */ -void HAL_MMC_TxCpltCallback(MMC_HandleTypeDef *hmmc); -void HAL_MMC_RxCpltCallback(MMC_HandleTypeDef *hmmc); -void HAL_MMC_ErrorCallback(MMC_HandleTypeDef *hmmc); -void HAL_MMC_AbortCallback(MMC_HandleTypeDef *hmmc); - -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) -/* MMC callback registering/unregistering */ -HAL_StatusTypeDef HAL_MMC_RegisterCallback(MMC_HandleTypeDef *hmmc, HAL_MMC_CallbackIDTypeDef CallbackId, - pMMC_CallbackTypeDef pCallback); -HAL_StatusTypeDef HAL_MMC_UnRegisterCallback(MMC_HandleTypeDef *hmmc, HAL_MMC_CallbackIDTypeDef CallbackId); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group3 Peripheral Control functions - * @{ - */ -HAL_StatusTypeDef HAL_MMC_ConfigWideBusOperation(MMC_HandleTypeDef *hmmc, uint32_t WideMode); -HAL_StatusTypeDef HAL_MMC_ConfigSpeedBusOperation(MMC_HandleTypeDef *hmmc, uint32_t SpeedMode); -HAL_StatusTypeDef HAL_MMC_SwitchPartition(MMC_HandleTypeDef *hmmc, HAL_MMC_PartitionTypeDef Partition); -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group4 MMC card related functions - * @{ - */ -HAL_MMC_CardStateTypeDef HAL_MMC_GetCardState(MMC_HandleTypeDef *hmmc); -HAL_StatusTypeDef HAL_MMC_GetCardCID(const MMC_HandleTypeDef *hmmc, HAL_MMC_CardCIDTypeDef *pCID); -HAL_StatusTypeDef HAL_MMC_GetCardCSD(MMC_HandleTypeDef *hmmc, HAL_MMC_CardCSDTypeDef *pCSD); -HAL_StatusTypeDef HAL_MMC_GetCardInfo(const MMC_HandleTypeDef *hmmc, HAL_MMC_CardInfoTypeDef *pCardInfo); -HAL_StatusTypeDef HAL_MMC_GetCardExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pExtCSD, uint32_t Timeout); -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group5 Peripheral State and Errors functions - * @{ - */ -HAL_MMC_StateTypeDef HAL_MMC_GetState(const MMC_HandleTypeDef *hmmc); -uint32_t HAL_MMC_GetError(const MMC_HandleTypeDef *hmmc); -uint32_t HAL_MMC_GetRPMBError(const MMC_HandleTypeDef *hmmc); -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group6 Peripheral Abort management - * @{ - */ -HAL_StatusTypeDef HAL_MMC_Abort(MMC_HandleTypeDef *hmmc); -HAL_StatusTypeDef HAL_MMC_Abort_IT(MMC_HandleTypeDef *hmmc); -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group7 Peripheral Erase management - * @{ - */ -HAL_StatusTypeDef HAL_MMC_EraseSequence(MMC_HandleTypeDef *hmmc, uint32_t EraseType, uint32_t BlockStartAdd, - uint32_t BlockEndAdd); -HAL_StatusTypeDef HAL_MMC_Sanitize(MMC_HandleTypeDef *hmmc); -HAL_StatusTypeDef HAL_MMC_ConfigSecRemovalType(MMC_HandleTypeDef *hmmc, uint32_t SRTMode); -HAL_StatusTypeDef HAL_MMC_GetSupportedSecRemovalType(MMC_HandleTypeDef *hmmc, uint32_t *SupportedSRT); -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group8 Peripheral Sleep management - * @{ - */ -HAL_StatusTypeDef HAL_MMC_SleepDevice(MMC_HandleTypeDef *hmmc); -HAL_StatusTypeDef HAL_MMC_AwakeDevice(MMC_HandleTypeDef *hmmc); -/** - * @} - */ - -/** @defgroup MMC_Exported_Functions_Group9 Replay Protected Memory Block management - * @{ - */ -HAL_StatusTypeDef HAL_MMC_RPMB_ProgramAuthenticationKey(MMC_HandleTypeDef *hmmc, const uint8_t *pKey, uint32_t Timeout); -HAL_StatusTypeDef HAL_MMC_RPMB_ProgramAuthenticationKey_IT(MMC_HandleTypeDef *hmmc, const uint8_t *pKey, - uint32_t Timeout); -uint32_t HAL_MMC_RPMB_GetWriteCounter(MMC_HandleTypeDef *hmmc, uint8_t *pNonce, uint32_t Timeout); -uint32_t HAL_MMC_RPMB_GetWriteCounter_IT(MMC_HandleTypeDef *hmmc, uint8_t *pNonce); -HAL_StatusTypeDef HAL_MMC_RPMB_WriteBlocks(MMC_HandleTypeDef *hmmc, const uint8_t *pData, uint16_t BlockAdd, - uint16_t NumberOfBlocks, const uint8_t *pMAC, uint32_t Timeout); -HAL_StatusTypeDef HAL_MMC_RPMB_WriteBlocks_IT(MMC_HandleTypeDef *hmmc, const uint8_t *pData, uint16_t BlockAdd, - uint16_t NumberOfBlocks, const uint8_t *pMAC); -HAL_StatusTypeDef HAL_MMC_RPMB_ReadBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint16_t BlockAdd, - uint16_t NumberOfBlocks, const uint8_t *pNonce, uint8_t *pMAC, - uint32_t Timeout); -HAL_StatusTypeDef HAL_MMC_RPMB_ReadBlocks_IT(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint16_t BlockAdd, - uint16_t NumberOfBlocks, const uint8_t *pNonce, uint8_t *pMAC); - -/** - * @} - */ - -/* Private types -------------------------------------------------------------*/ -/** @defgroup MMC_Private_Types MMC Private Types - * @{ - */ - -/** - * @} - */ - -/* Private defines -----------------------------------------------------------*/ -/** @defgroup MMC_Private_Defines MMC Private Defines - * @{ - */ -#define MMC_EXT_CSD_DATA_SEC_SIZE_INDEX 61 -#define MMC_EXT_CSD_DATA_SEC_SIZE_POS 8 -/** - * @} - */ - -/* Private variables ---------------------------------------------------------*/ -/** @defgroup MMC_Private_Variables MMC Private Variables - * @{ - */ - -/** - * @} - */ - -/* Private constants ---------------------------------------------------------*/ -/** @defgroup MMC_Private_Constants MMC Private Constants - * @{ - */ - -/** - * @} - */ - -/* Private macros ------------------------------------------------------------*/ -/** @defgroup MMC_Private_Macros MMC Private Macros - * @{ - */ - -/** - * @} - */ - -/* Private functions prototypes ----------------------------------------------*/ -/** @defgroup MMC_Private_Functions_Prototypes MMC Private Functions Prototypes - * @{ - */ - -/** - * @} - */ - -/* Private functions ---------------------------------------------------------*/ -/** @defgroup MMC_Private_Functions MMC Private Functions - * @{ - */ - -/** - * @} - */ - - -/** - * @} - */ - -/** - * @} - */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ - -#ifdef __cplusplus -} -#endif - - -#endif /* STM32H7xx_HAL_MMC_H */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc_ex.h b/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc_ex.h deleted file mode 100644 index c610a2b..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_mmc_ex.h +++ /dev/null @@ -1,113 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_mmc_ex.h - * @author MCD Application Team - * @brief Header file of SD HAL extended module. - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - */ - -/* Define to prevent recursive inclusion -------------------------------------*/ -#ifndef STM32H7xx_HAL_MMC_EX_H -#define STM32H7xx_HAL_MMC_EX_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal_def.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ -#if defined (SDMMC1) || defined (SDMMC2) -/** @addtogroup MMCEx - * @brief SD HAL extended module driver - * @{ - */ - -/* Exported types ------------------------------------------------------------*/ -/** @defgroup MMCEx_Exported_Types MMCEx Exported Types - * @{ - */ - -/** @defgroup MMCEx_Exported_Types_Group1 MMC Internal DMA Buffer structure - * @{ - */ -typedef enum -{ - MMC_DMA_BUFFER0 = 0x00U, /*!< selects MMC internal DMA Buffer 0 */ - MMC_DMA_BUFFER1 = 0x01U, /*!< selects MMC internal DMA Buffer 1 */ - -} HAL_MMCEx_DMABuffer_MemoryTypeDef; - - -/** - * @} - */ - -/** - * @} - */ -/* Exported functions --------------------------------------------------------*/ -/** @defgroup MMCEx_Exported_Functions MMCEx Exported Functions - * @{ - */ - -/** @defgroup MMCEx_Exported_Functions_Group1 MultiBuffer functions - * @{ - */ -HAL_StatusTypeDef HAL_MMCEx_ConfigDMAMultiBuffer(MMC_HandleTypeDef *hmmc, uint32_t *pDataBuffer0, - uint32_t *pDataBuffer1, uint32_t BufferSize); -HAL_StatusTypeDef HAL_MMCEx_ReadBlocksDMAMultiBuffer(MMC_HandleTypeDef *hmmc, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_MMCEx_WriteBlocksDMAMultiBuffer(MMC_HandleTypeDef *hmmc, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_MMCEx_ChangeDMABuffer(MMC_HandleTypeDef *hmmc, HAL_MMCEx_DMABuffer_MemoryTypeDef Buffer, - uint32_t *pDataBuffer); - -void HAL_MMCEx_Read_DMADoubleBuf0CpltCallback(MMC_HandleTypeDef *hmmc); -void HAL_MMCEx_Read_DMADoubleBuf1CpltCallback(MMC_HandleTypeDef *hmmc); -void HAL_MMCEx_Write_DMADoubleBuf0CpltCallback(MMC_HandleTypeDef *hmmc); -void HAL_MMCEx_Write_DMADoubleBuf1CpltCallback(MMC_HandleTypeDef *hmmc); - -/** - * @} - */ - -/** - * @} - */ - -/* Private types -------------------------------------------------------------*/ -/* Private defines -----------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -/* Private constants ---------------------------------------------------------*/ -/* Private macros ------------------------------------------------------------*/ -/* Private functions prototypes ----------------------------------------------*/ -/* Private functions ---------------------------------------------------------*/ - -/** - * @} - */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ -#ifdef __cplusplus -} -#endif - - -#endif /* STM32H7xx_HAL_MMCEx_H */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd.h b/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd.h deleted file mode 100644 index a2536da..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd.h +++ /dev/null @@ -1,802 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_sd.h - * @author MCD Application Team - * @brief Header file of SD HAL module. - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - */ - -/* Define to prevent recursive inclusion -------------------------------------*/ -#ifndef STM32H7xx_HAL_SD_H -#define STM32H7xx_HAL_SD_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_ll_sdmmc.h" -#if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2) || defined (DLYB_SDMMC3) -#include "stm32h7xx_ll_delayblock.h" -#endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */ - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ -#if defined (SDMMC1) || defined (SDMMC2) - -/** @defgroup SD SD - * @brief SD HAL module driver - * @{ - */ - -/* Exported types ------------------------------------------------------------*/ -/** @defgroup SD_Exported_Types SD Exported Types - * @{ - */ - -/** @defgroup SD_Exported_Types_Group1 SD State enumeration structure - * @{ - */ -typedef enum -{ - HAL_SD_STATE_RESET = ((uint32_t)0x00000000U), /*!< SD not yet initialized or disabled */ - HAL_SD_STATE_READY = ((uint32_t)0x00000001U), /*!< SD initialized and ready for use */ - HAL_SD_STATE_TIMEOUT = ((uint32_t)0x00000002U), /*!< SD Timeout state */ - HAL_SD_STATE_BUSY = ((uint32_t)0x00000003U), /*!< SD process ongoing */ - HAL_SD_STATE_PROGRAMMING = ((uint32_t)0x00000004U), /*!< SD Programming State */ - HAL_SD_STATE_RECEIVING = ((uint32_t)0x00000005U), /*!< SD Receiving State */ - HAL_SD_STATE_TRANSFER = ((uint32_t)0x00000006U), /*!< SD Transfer State */ - HAL_SD_STATE_ERROR = ((uint32_t)0x0000000FU) /*!< SD is in error state */ -} HAL_SD_StateTypeDef; -/** - * @} - */ - -/** @defgroup SD_Exported_Types_Group2 SD Card State enumeration structure - * @{ - */ -typedef uint32_t HAL_SD_CardStateTypeDef; - -#define HAL_SD_CARD_READY 0x00000001U /*!< Card state is ready */ -#define HAL_SD_CARD_IDENTIFICATION 0x00000002U /*!< Card is in identification state */ -#define HAL_SD_CARD_STANDBY 0x00000003U /*!< Card is in standby state */ -#define HAL_SD_CARD_TRANSFER 0x00000004U /*!< Card is in transfer state */ -#define HAL_SD_CARD_SENDING 0x00000005U /*!< Card is sending an operation */ -#define HAL_SD_CARD_RECEIVING 0x00000006U /*!< Card is receiving operation information */ -#define HAL_SD_CARD_PROGRAMMING 0x00000007U /*!< Card is in programming state */ -#define HAL_SD_CARD_DISCONNECTED 0x00000008U /*!< Card is disconnected */ -#define HAL_SD_CARD_ERROR 0x000000FFU /*!< Card response Error */ -/** - * @} - */ - -/** @defgroup SD_Exported_Types_Group3 SD Handle Structure definition - * @{ - */ -#define SD_InitTypeDef SDMMC_InitTypeDef -#define SD_TypeDef SDMMC_TypeDef - -/** - * @brief SD Card Information Structure definition - */ -typedef struct -{ - uint32_t CardType; /*!< Specifies the card Type */ - - uint32_t CardVersion; /*!< Specifies the card version */ - - uint32_t Class; /*!< Specifies the class of the card class */ - - uint32_t RelCardAdd; /*!< Specifies the Relative Card Address */ - - uint32_t BlockNbr; /*!< Specifies the Card Capacity in blocks */ - - uint32_t BlockSize; /*!< Specifies one block size in bytes */ - - uint32_t LogBlockNbr; /*!< Specifies the Card logical Capacity in blocks */ - - uint32_t LogBlockSize; /*!< Specifies logical block size in bytes */ - - uint32_t CardSpeed; /*!< Specifies the card Speed */ - -} HAL_SD_CardInfoTypeDef; - -/** - * @brief SD handle Structure definition - */ -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) -typedef struct __SD_HandleTypeDef -#else -typedef struct -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ -{ - SD_TypeDef *Instance; /*!< SD registers base address */ - - SD_InitTypeDef Init; /*!< SD required parameters */ - - HAL_LockTypeDef Lock; /*!< SD locking object */ - - const uint8_t *pTxBuffPtr; /*!< Pointer to SD Tx transfer Buffer */ - - uint32_t TxXferSize; /*!< SD Tx Transfer size */ - - uint8_t *pRxBuffPtr; /*!< Pointer to SD Rx transfer Buffer */ - - uint32_t RxXferSize; /*!< SD Rx Transfer size */ - - __IO uint32_t Context; /*!< SD transfer context */ - - __IO HAL_SD_StateTypeDef State; /*!< SD card State */ - - __IO uint32_t ErrorCode; /*!< SD Card Error codes */ - - HAL_SD_CardInfoTypeDef SdCard; /*!< SD Card information */ - - uint32_t CSD[4]; /*!< SD card specific data table */ - - uint32_t CID[4]; /*!< SD card identification number table */ - -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - void (* TxCpltCallback)(struct __SD_HandleTypeDef *hsd); - void (* RxCpltCallback)(struct __SD_HandleTypeDef *hsd); - void (* ErrorCallback)(struct __SD_HandleTypeDef *hsd); - void (* AbortCpltCallback)(struct __SD_HandleTypeDef *hsd); - void (* Read_DMADblBuf0CpltCallback)(struct __SD_HandleTypeDef *hsd); - void (* Read_DMADblBuf1CpltCallback)(struct __SD_HandleTypeDef *hsd); - void (* Write_DMADblBuf0CpltCallback)(struct __SD_HandleTypeDef *hsd); - void (* Write_DMADblBuf1CpltCallback)(struct __SD_HandleTypeDef *hsd); -#if (USE_SD_TRANSCEIVER != 0U) - void (* DriveTransceiver_1_8V_Callback)(FlagStatus status); -#endif /* USE_SD_TRANSCEIVER */ - - void (* MspInitCallback)(struct __SD_HandleTypeDef *hsd); - void (* MspDeInitCallback)(struct __SD_HandleTypeDef *hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ -} SD_HandleTypeDef; - -/** - * @} - */ - -/** @defgroup SD_Exported_Types_Group4 Card Specific Data: CSD Register - * @{ - */ -typedef struct -{ - __IO uint8_t CSDStruct; /*!< CSD structure */ - __IO uint8_t SysSpecVersion; /*!< System specification version */ - __IO uint8_t Reserved1; /*!< Reserved */ - __IO uint8_t TAAC; /*!< Data read access time 1 */ - __IO uint8_t NSAC; /*!< Data read access time 2 in CLK cycles */ - __IO uint8_t MaxBusClkFrec; /*!< Max. bus clock frequency */ - __IO uint16_t CardComdClasses; /*!< Card command classes */ - __IO uint8_t RdBlockLen; /*!< Max. read data block length */ - __IO uint8_t PartBlockRead; /*!< Partial blocks for read allowed */ - __IO uint8_t WrBlockMisalign; /*!< Write block misalignment */ - __IO uint8_t RdBlockMisalign; /*!< Read block misalignment */ - __IO uint8_t DSRImpl; /*!< DSR implemented */ - __IO uint8_t Reserved2; /*!< Reserved */ - __IO uint32_t DeviceSize; /*!< Device Size */ - __IO uint8_t MaxRdCurrentVDDMin; /*!< Max. read current @ VDD min */ - __IO uint8_t MaxRdCurrentVDDMax; /*!< Max. read current @ VDD max */ - __IO uint8_t MaxWrCurrentVDDMin; /*!< Max. write current @ VDD min */ - __IO uint8_t MaxWrCurrentVDDMax; /*!< Max. write current @ VDD max */ - __IO uint8_t DeviceSizeMul; /*!< Device size multiplier */ - __IO uint8_t EraseGrSize; /*!< Erase group size */ - __IO uint8_t EraseGrMul; /*!< Erase group size multiplier */ - __IO uint8_t WrProtectGrSize; /*!< Write protect group size */ - __IO uint8_t WrProtectGrEnable; /*!< Write protect group enable */ - __IO uint8_t ManDeflECC; /*!< Manufacturer default ECC */ - __IO uint8_t WrSpeedFact; /*!< Write speed factor */ - __IO uint8_t MaxWrBlockLen; /*!< Max. write data block length */ - __IO uint8_t WriteBlockPaPartial; /*!< Partial blocks for write allowed */ - __IO uint8_t Reserved3; /*!< Reserved */ - __IO uint8_t ContentProtectAppli; /*!< Content protection application */ - __IO uint8_t FileFormatGroup; /*!< File format group */ - __IO uint8_t CopyFlag; /*!< Copy flag (OTP) */ - __IO uint8_t PermWrProtect; /*!< Permanent write protection */ - __IO uint8_t TempWrProtect; /*!< Temporary write protection */ - __IO uint8_t FileFormat; /*!< File format */ - __IO uint8_t ECC; /*!< ECC code */ - __IO uint8_t CSD_CRC; /*!< CSD CRC */ - __IO uint8_t Reserved4; /*!< Always 1 */ -} HAL_SD_CardCSDTypeDef; -/** - * @} - */ - -/** @defgroup SD_Exported_Types_Group5 Card Identification Data: CID Register - * @{ - */ -typedef struct -{ - __IO uint8_t ManufacturerID; /*!< Manufacturer ID */ - __IO uint16_t OEM_AppliID; /*!< OEM/Application ID */ - __IO uint32_t ProdName1; /*!< Product Name part1 */ - __IO uint8_t ProdName2; /*!< Product Name part2 */ - __IO uint8_t ProdRev; /*!< Product Revision */ - __IO uint32_t ProdSN; /*!< Product Serial Number */ - __IO uint8_t Reserved1; /*!< Reserved1 */ - __IO uint16_t ManufactDate; /*!< Manufacturing Date */ - __IO uint8_t CID_CRC; /*!< CID CRC */ - __IO uint8_t Reserved2; /*!< Always 1 */ - -} HAL_SD_CardCIDTypeDef; -/** - * @} - */ - -/** @defgroup SD_Exported_Types_Group6 SD Card Status returned by ACMD13 - * @{ - */ -typedef struct -{ - __IO uint8_t DataBusWidth; /*!< Shows the currently defined data bus width */ - __IO uint8_t SecuredMode; /*!< Card is in secured mode of operation */ - __IO uint16_t CardType; /*!< Carries information about card type */ - __IO uint32_t ProtectedAreaSize; /*!< Carries information about the capacity of protected area */ - __IO uint8_t SpeedClass; /*!< Carries information about the speed class of the card */ - __IO uint8_t PerformanceMove; /*!< Carries information about the card's performance move */ - __IO uint8_t AllocationUnitSize; /*!< Carries information about the card's allocation unit size */ - __IO uint16_t EraseSize; /*!< Determines the number of AUs to be erased in one operation */ - __IO uint8_t EraseTimeout; /*!< Determines the timeout for any number of AU erase */ - __IO uint8_t EraseOffset; /*!< Carries information about the erase offset */ - __IO uint8_t UhsSpeedGrade; /*!< Carries information about the speed grade of UHS card */ - __IO uint8_t UhsAllocationUnitSize; /*!< Carries information about the UHS card's allocation unit size */ - __IO uint8_t VideoSpeedClass; /*!< Carries information about the Video Speed Class of UHS card */ -} HAL_SD_CardStatusTypeDef; -/** - * @} - */ - -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) -/** @defgroup SD_Exported_Types_Group7 SD Callback ID enumeration definition - * @{ - */ -typedef enum -{ - HAL_SD_TX_CPLT_CB_ID = 0x00U, /*!< SD Tx Complete Callback ID */ - HAL_SD_RX_CPLT_CB_ID = 0x01U, /*!< SD Rx Complete Callback ID */ - HAL_SD_ERROR_CB_ID = 0x02U, /*!< SD Error Callback ID */ - HAL_SD_ABORT_CB_ID = 0x03U, /*!< SD Abort Callback ID */ - HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID = 0x04U, /*!< SD Rx DMA Double Buffer 0 Complete Callback ID */ - HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID = 0x05U, /*!< SD Rx DMA Double Buffer 1 Complete Callback ID */ - HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID = 0x06U, /*!< SD Tx DMA Double Buffer 0 Complete Callback ID */ - HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID = 0x07U, /*!< SD Tx DMA Double Buffer 1 Complete Callback ID */ - - HAL_SD_MSP_INIT_CB_ID = 0x10U, /*!< SD MspInit Callback ID */ - HAL_SD_MSP_DEINIT_CB_ID = 0x11U /*!< SD MspDeInit Callback ID */ -} HAL_SD_CallbackIDTypeDef; -/** - * @} - */ - -/** @defgroup SD_Exported_Types_Group8 SD Callback pointer definition - * @{ - */ -typedef void (*pSD_CallbackTypeDef)(SD_HandleTypeDef *hsd); -#if (USE_SD_TRANSCEIVER != 0U) -typedef void (*pSD_TransceiverCallbackTypeDef)(FlagStatus status); -#endif /* USE_SD_TRANSCEIVER */ -/** - * @} - */ -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ -/** - * @} - */ - -/* Exported constants --------------------------------------------------------*/ -/** @defgroup SD_Exported_Constants SD Exported Constants - * @{ - */ - -#define BLOCKSIZE ((uint32_t)512U) /*!< Block size is 512 bytes */ - -/** @defgroup SD_Exported_Constansts_Group1 SD Error status enumeration Structure definition - * @{ - */ -#define HAL_SD_ERROR_NONE SDMMC_ERROR_NONE /*!< No error */ -#define HAL_SD_ERROR_CMD_CRC_FAIL SDMMC_ERROR_CMD_CRC_FAIL /*!< Command response received (but CRC check failed) */ -#define HAL_SD_ERROR_DATA_CRC_FAIL SDMMC_ERROR_DATA_CRC_FAIL /*!< Data block sent/received (CRC check failed) */ -#define HAL_SD_ERROR_CMD_RSP_TIMEOUT SDMMC_ERROR_CMD_RSP_TIMEOUT /*!< Command response timeout */ -#define HAL_SD_ERROR_DATA_TIMEOUT SDMMC_ERROR_DATA_TIMEOUT /*!< Data timeout */ -#define HAL_SD_ERROR_TX_UNDERRUN SDMMC_ERROR_TX_UNDERRUN /*!< Transmit FIFO underrun */ -#define HAL_SD_ERROR_RX_OVERRUN SDMMC_ERROR_RX_OVERRUN /*!< Receive FIFO overrun */ -#define HAL_SD_ERROR_ADDR_MISALIGNED SDMMC_ERROR_ADDR_MISALIGNED /*!< Misaligned address */ -#define HAL_SD_ERROR_BLOCK_LEN_ERR SDMMC_ERROR_BLOCK_LEN_ERR /*!< Transferred block length is not allowed for the card or the */ -/*!< number of transferred bytes does not match the block length */ -#define HAL_SD_ERROR_ERASE_SEQ_ERR SDMMC_ERROR_ERASE_SEQ_ERR /*!< An error in the sequence of erase command occurs */ -#define HAL_SD_ERROR_BAD_ERASE_PARAM SDMMC_ERROR_BAD_ERASE_PARAM /*!< An invalid selection for erase groups */ -#define HAL_SD_ERROR_WRITE_PROT_VIOLATION SDMMC_ERROR_WRITE_PROT_VIOLATION /*!< Attempt to program a write protect block */ -#define HAL_SD_ERROR_LOCK_UNLOCK_FAILED SDMMC_ERROR_LOCK_UNLOCK_FAILED /*!< Sequence or password error has been detected in unlock */ -/*!< command or if there was an attempt to access a locked card */ -#define HAL_SD_ERROR_COM_CRC_FAILED SDMMC_ERROR_COM_CRC_FAILED /*!< CRC check of the previous command failed */ -#define HAL_SD_ERROR_ILLEGAL_CMD SDMMC_ERROR_ILLEGAL_CMD /*!< Command is not legal for the card state */ -#define HAL_SD_ERROR_CARD_ECC_FAILED SDMMC_ERROR_CARD_ECC_FAILED /*!< Card internal ECC was applied but failed to correct the data */ -#define HAL_SD_ERROR_CC_ERR SDMMC_ERROR_CC_ERR /*!< Internal card controller error */ -#define HAL_SD_ERROR_GENERAL_UNKNOWN_ERR SDMMC_ERROR_GENERAL_UNKNOWN_ERR /*!< General or unknown error */ -#define HAL_SD_ERROR_STREAM_READ_UNDERRUN SDMMC_ERROR_STREAM_READ_UNDERRUN /*!< The card could not sustain data reading in stream rmode */ -#define HAL_SD_ERROR_STREAM_WRITE_OVERRUN SDMMC_ERROR_STREAM_WRITE_OVERRUN /*!< The card could not sustain data programming in stream mode */ -#define HAL_SD_ERROR_CID_CSD_OVERWRITE SDMMC_ERROR_CID_CSD_OVERWRITE /*!< CID/CSD overwrite error */ -#define HAL_SD_ERROR_WP_ERASE_SKIP SDMMC_ERROR_WP_ERASE_SKIP /*!< Only partial address space was erased */ -#define HAL_SD_ERROR_CARD_ECC_DISABLED SDMMC_ERROR_CARD_ECC_DISABLED /*!< Command has been executed without using internal ECC */ -#define HAL_SD_ERROR_ERASE_RESET SDMMC_ERROR_ERASE_RESET /*!< Erase sequence was cleared before executing because an out */ -/*!< of erase sequence command was received */ -#define HAL_SD_ERROR_AKE_SEQ_ERR SDMMC_ERROR_AKE_SEQ_ERR /*!< Error in sequence of authentication */ -#define HAL_SD_ERROR_INVALID_VOLTRANGE SDMMC_ERROR_INVALID_VOLTRANGE /*!< Error in case of invalid voltage range */ -#define HAL_SD_ERROR_ADDR_OUT_OF_RANGE SDMMC_ERROR_ADDR_OUT_OF_RANGE /*!< Error when addressed block is out of range */ -#define HAL_SD_ERROR_REQUEST_NOT_APPLICABLE SDMMC_ERROR_REQUEST_NOT_APPLICABLE /*!< Error when command request is not applicable */ -#define HAL_SD_ERROR_PARAM SDMMC_ERROR_INVALID_PARAMETER /*!< the used parameter is not valid */ -#define HAL_SD_ERROR_UNSUPPORTED_FEATURE SDMMC_ERROR_UNSUPPORTED_FEATURE /*!< Error when feature is not insupported */ -#define HAL_SD_ERROR_BUSY SDMMC_ERROR_BUSY /*!< Error when transfer process is busy */ -#define HAL_SD_ERROR_DMA SDMMC_ERROR_DMA /*!< Error while DMA transfer */ -#define HAL_SD_ERROR_TIMEOUT SDMMC_ERROR_TIMEOUT /*!< Timeout error */ - -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) -#define HAL_SD_ERROR_INVALID_CALLBACK SDMMC_ERROR_INVALID_PARAMETER /*!< Invalid callback error */ -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ -/** - * @} - */ - -/** @defgroup SD_Exported_Constansts_Group2 SD context enumeration - * @{ - */ -#define SD_CONTEXT_NONE ((uint32_t)0x00000000U) /*!< None */ -#define SD_CONTEXT_READ_SINGLE_BLOCK ((uint32_t)0x00000001U) /*!< Read single block operation */ -#define SD_CONTEXT_READ_MULTIPLE_BLOCK ((uint32_t)0x00000002U) /*!< Read multiple blocks operation */ -#define SD_CONTEXT_WRITE_SINGLE_BLOCK ((uint32_t)0x00000010U) /*!< Write single block operation */ -#define SD_CONTEXT_WRITE_MULTIPLE_BLOCK ((uint32_t)0x00000020U) /*!< Write multiple blocks operation */ -#define SD_CONTEXT_IT ((uint32_t)0x00000008U) /*!< Process in Interrupt mode */ -#define SD_CONTEXT_DMA ((uint32_t)0x00000080U) /*!< Process in DMA mode */ - -/** - * @} - */ - -/** @defgroup SD_Exported_Constansts_Group3 SD Supported Memory Cards - * @{ - */ -#define CARD_NORMAL_SPEED ((uint32_t)0x00000000U) /*!< Normal Speed Card <12.5Mo/s , Spec Version 1.01 */ -#define CARD_HIGH_SPEED ((uint32_t)0x00000100U) /*!< High Speed Card <25Mo/s , Spec version 2.00 */ -#define CARD_ULTRA_HIGH_SPEED ((uint32_t)0x00000200U) /*!< UHS-I SD Card <50Mo/s for SDR50, DDR5 Cards - and <104Mo/s for SDR104, Spec version 3.01 */ - -#define CARD_SDSC ((uint32_t)0x00000000U) /*!< SD Standard Capacity <2Go */ -#define CARD_SDHC_SDXC ((uint32_t)0x00000001U) /*!< SD High Capacity <32Go, SD Extended Capacity <2To */ -#define CARD_SECURED ((uint32_t)0x00000003U) - -/** - * @} - */ - -/** @defgroup SD_Exported_Constansts_Group4 SD Supported Version - * @{ - */ -#define CARD_V1_X ((uint32_t)0x00000000U) -#define CARD_V2_X ((uint32_t)0x00000001U) -/** - * @} - */ - -/** - * @} - */ - -/* Exported macro ------------------------------------------------------------*/ -/** @defgroup SD_Exported_macros SD Exported Macros - * @brief macros to handle interrupts and specific clock configurations - * @{ - */ -/** @brief Reset SD handle state. - * @param __HANDLE__ SD Handle. - * @retval None - */ -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) -#define __HAL_SD_RESET_HANDLE_STATE(__HANDLE__) do { \ - (__HANDLE__)->State = HAL_SD_STATE_RESET; \ - (__HANDLE__)->MspInitCallback = NULL; \ - (__HANDLE__)->MspDeInitCallback = NULL; \ - } while(0) -#else -#define __HAL_SD_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_SD_STATE_RESET) -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - -/** - * @brief Enable the SD device interrupt. - * @param __HANDLE__ SD Handle. - * @param __INTERRUPT__ specifies the SDMMC interrupt sources to be enabled. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __HAL_SD_ENABLE_IT(__HANDLE__, __INTERRUPT__) __SDMMC_ENABLE_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @brief Disable the SD device interrupt. - * @param __HANDLE__ SD Handle. - * @param __INTERRUPT__ specifies the SDMMC interrupt sources to be disabled. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __HAL_SD_DISABLE_IT(__HANDLE__, __INTERRUPT__) __SDMMC_DISABLE_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @brief Check whether the specified SD flag is set or not. - * @param __HANDLE__ SD Handle. - * @param __FLAG__ specifies the flag to check. - * This parameter can be one of the following values: - * @arg SDMMC_FLAG_CCRCFAIL: Command response received (CRC check failed) - * @arg SDMMC_FLAG_DCRCFAIL: Data block sent/received (CRC check failed) - * @arg SDMMC_FLAG_CTIMEOUT: Command response timeout - * @arg SDMMC_FLAG_DTIMEOUT: Data timeout - * @arg SDMMC_FLAG_TXUNDERR: Transmit FIFO underrun error - * @arg SDMMC_FLAG_RXOVERR: Received FIFO overrun error - * @arg SDMMC_FLAG_CMDREND: Command response received (CRC check passed) - * @arg SDMMC_FLAG_CMDSENT: Command sent (no response required) - * @arg SDMMC_FLAG_DATAEND: Data end (data counter, DATACOUNT, is zero) - * @arg SDMMC_FLAG_DHOLD: Data transfer Hold - * @arg SDMMC_FLAG_DBCKEND: Data block sent/received (CRC check passed) - * @arg SDMMC_FLAG_DABORT: Data transfer aborted by CMD12 - * @arg SDMMC_FLAG_DPSMACT: Data path state machine active - * @arg SDMMC_FLAG_CPSMACT: Command path state machine active - * @arg SDMMC_FLAG_TXFIFOHE: Transmit FIFO Half Empty - * @arg SDMMC_FLAG_RXFIFOHF: Receive FIFO Half Full - * @arg SDMMC_FLAG_TXFIFOF: Transmit FIFO full - * @arg SDMMC_FLAG_RXFIFOF: Receive FIFO full - * @arg SDMMC_FLAG_TXFIFOE: Transmit FIFO empty - * @arg SDMMC_FLAG_RXFIFOE: Receive FIFO empty - * @arg SDMMC_FLAG_BUSYD0: Inverted value of SDMMC_D0 line (Busy) - * @arg SDMMC_FLAG_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected - * @arg SDMMC_FLAG_SDIOIT: SDIO interrupt received - * @arg SDMMC_FLAG_ACKFAIL: Boot Acknowledgment received - * @arg SDMMC_FLAG_ACKTIMEOUT: Boot Acknowledgment timeout - * @arg SDMMC_FLAG_VSWEND: Voltage switch critical timing section completion - * @arg SDMMC_FLAG_CKSTOP: SDMMC_CK stopped in Voltage switch procedure - * @arg SDMMC_FLAG_IDMATE: IDMA transfer error - * @arg SDMMC_FLAG_IDMABTC: IDMA buffer transfer complete - * @retval The new state of SD FLAG (SET or RESET). - */ -#define __HAL_SD_GET_FLAG(__HANDLE__, __FLAG__) __SDMMC_GET_FLAG((__HANDLE__)->Instance, (__FLAG__)) - -/** - * @brief Clear the SD's pending flags. - * @param __HANDLE__ SD Handle. - * @param __FLAG__ specifies the flag to clear. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_FLAG_CCRCFAIL: Command response received (CRC check failed) - * @arg SDMMC_FLAG_DCRCFAIL: Data block sent/received (CRC check failed) - * @arg SDMMC_FLAG_CTIMEOUT: Command response timeout - * @arg SDMMC_FLAG_DTIMEOUT: Data timeout - * @arg SDMMC_FLAG_TXUNDERR: Transmit FIFO underrun error - * @arg SDMMC_FLAG_RXOVERR: Received FIFO overrun error - * @arg SDMMC_FLAG_CMDREND: Command response received (CRC check passed) - * @arg SDMMC_FLAG_CMDSENT: Command sent (no response required) - * @arg SDMMC_FLAG_DATAEND: Data end (data counter, DATACOUNT, is zero) - * @arg SDMMC_FLAG_DHOLD: Data transfer Hold - * @arg SDMMC_FLAG_DBCKEND: Data block sent/received (CRC check passed) - * @arg SDMMC_FLAG_DABORT: Data transfer aborted by CMD12 - * @arg SDMMC_FLAG_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected - * @arg SDMMC_FLAG_SDIOIT: SDIO interrupt received - * @arg SDMMC_FLAG_ACKFAIL: Boot Acknowledgment received - * @arg SDMMC_FLAG_ACKTIMEOUT: Boot Acknowledgment timeout - * @arg SDMMC_FLAG_VSWEND: Voltage switch critical timing section completion - * @arg SDMMC_FLAG_CKSTOP: SDMMC_CK stopped in Voltage switch procedure - * @arg SDMMC_FLAG_IDMATE: IDMA transfer error - * @arg SDMMC_FLAG_IDMABTC: IDMA buffer transfer complete - * @retval None - */ -#define __HAL_SD_CLEAR_FLAG(__HANDLE__, __FLAG__) __SDMMC_CLEAR_FLAG((__HANDLE__)->Instance, (__FLAG__)) - -/** - * @brief Check whether the specified SD interrupt has occurred or not. - * @param __HANDLE__ SD Handle. - * @param __INTERRUPT__ specifies the SDMMC interrupt source to check. - * This parameter can be one of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval The new state of SD IT (SET or RESET). - */ -#define __HAL_SD_GET_IT(__HANDLE__, __INTERRUPT__) __SDMMC_GET_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @brief Clear the SD's interrupt pending bits. - * @param __HANDLE__ SD Handle. - * @param __INTERRUPT__ specifies the interrupt pending bit to clear. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __HAL_SD_CLEAR_IT(__HANDLE__, __INTERRUPT__) __SDMMC_CLEAR_IT((__HANDLE__)->Instance, (__INTERRUPT__)) - -/** - * @} - */ - -/* Include SD HAL Extension module */ -#include "stm32h7xx_hal_sd_ex.h" - -/* Exported functions --------------------------------------------------------*/ -/** @defgroup SD_Exported_Functions SD Exported Functions - * @{ - */ - -/** @defgroup SD_Exported_Functions_Group1 Initialization and de-initialization functions - * @{ - */ -HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd); -HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd); -HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd); -void HAL_SD_MspInit(SD_HandleTypeDef *hsd); -void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd); -/** - * @} - */ - -/** @defgroup SD_Exported_Functions_Group2 Input and Output operation functions - * @{ - */ -/* Blocking mode: Polling */ -HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, - uint32_t Timeout); -HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks, uint32_t Timeout); -HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd); -/* Non-Blocking mode: IT */ -HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -/* Non-Blocking mode: DMA */ -HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks); - -void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd); - -/* Callback in non blocking modes (DMA) */ -void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd); -void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd); -void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd); -void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd); - -#if (USE_SD_TRANSCEIVER != 0U) -/* Callback to switch in 1.8V mode */ -void HAL_SD_DriveTransceiver_1_8V_Callback(FlagStatus status); -#endif /* USE_SD_TRANSCEIVER */ - -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) -/* SD callback registering/unregistering */ -HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, - pSD_CallbackTypeDef pCallback); -HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID); - -#if (USE_SD_TRANSCEIVER != 0U) -HAL_StatusTypeDef HAL_SD_RegisterTransceiverCallback(SD_HandleTypeDef *hsd, pSD_TransceiverCallbackTypeDef pCallback); -HAL_StatusTypeDef HAL_SD_UnRegisterTransceiverCallback(SD_HandleTypeDef *hsd); -#endif /* USE_SD_TRANSCEIVER */ -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - -/** - * @} - */ - -/** @defgroup SD_Exported_Functions_Group3 Peripheral Control functions - * @{ - */ -HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode); -HAL_StatusTypeDef HAL_SD_ConfigSpeedBusOperation(SD_HandleTypeDef *hsd, uint32_t SpeedMode); -/** - * @} - */ - -/** @defgroup SD_Exported_Functions_Group4 SD card related functions - * @{ - */ -HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd); -HAL_StatusTypeDef HAL_SD_GetCardCID(const SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID); -HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD); -HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus); -HAL_StatusTypeDef HAL_SD_GetCardInfo(const SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo); -/** - * @} - */ - -/** @defgroup SD_Exported_Functions_Group5 Peripheral State and Errors functions - * @{ - */ -HAL_SD_StateTypeDef HAL_SD_GetState(const SD_HandleTypeDef *hsd); -uint32_t HAL_SD_GetError(const SD_HandleTypeDef *hsd); -/** - * @} - */ - -/** @defgroup SD_Exported_Functions_Group6 Perioheral Abort management - * @{ - */ -HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd); -HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd); -/** - * @} - */ - -/* Private types -------------------------------------------------------------*/ -/** @defgroup SD_Private_Types SD Private Types - * @{ - */ - -/** - * @} - */ - -/* Private defines -----------------------------------------------------------*/ -/** @defgroup SD_Private_Defines SD Private Defines - * @{ - */ - -/** - * @} - */ - -/* Private variables ---------------------------------------------------------*/ -/** @defgroup SD_Private_Variables SD Private Variables - * @{ - */ - -/** - * @} - */ - -/* Private constants ---------------------------------------------------------*/ -/** @defgroup SD_Private_Constants SD Private Constants - * @{ - */ - -/** - * @} - */ - -/* Private macros ------------------------------------------------------------*/ -/** @defgroup SD_Private_Macros SD Private Macros - * @{ - */ - -/** - * @} - */ - -/* Private functions prototypes ----------------------------------------------*/ -/** @defgroup SD_Private_Functions_Prototypes SD Private Functions Prototypes - * @{ - */ - -/** - * @} - */ - -/* Private functions ---------------------------------------------------------*/ -/** @defgroup SD_Private_Functions SD Private Functions - * @{ - */ - -/** - * @} - */ - - -/** - * @} - */ - -/** - * @} - */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ - -#ifdef __cplusplus -} -#endif - - -#endif /* STM32H7xx_HAL_SD_H */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd_ex.h b/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd_ex.h deleted file mode 100644 index 050005b..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_sd_ex.h +++ /dev/null @@ -1,112 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_sd_ex.h - * @author MCD Application Team - * @brief Header file of SD HAL extended module. - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - */ - -/* Define to prevent recursive inclusion -------------------------------------*/ -#ifndef STM32H7xx_HAL_SD_EX_H -#define STM32H7xx_HAL_SD_EX_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal_def.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ -#if defined (SDMMC1) || defined (SDMMC2) - -/** @addtogroup SDEx - * @brief SD HAL extended module driver - * @{ - */ - -/* Exported types ------------------------------------------------------------*/ -/** @defgroup SDEx_Exported_Types SDEx Exported Types - * @{ - */ - -/** @defgroup SDEx_Exported_Types_Group1 SD Card Internal DMA Buffer structure - * @{ - */ -typedef enum -{ - SD_DMA_BUFFER0 = 0x00U, /*!< selects SD internal DMA Buffer 0 */ - SD_DMA_BUFFER1 = 0x01U, /*!< selects SD internal DMA Buffer 1 */ - -} HAL_SDEx_DMABuffer_MemoryTypeDef; - -/** - * @} - */ -/** - * @} - */ - -/* Exported functions --------------------------------------------------------*/ -/** @defgroup SDEx_Exported_Functions SDEx Exported Functions - * @{ - */ - -/** @defgroup SDEx_Exported_Functions_Group1 MultiBuffer functions - * @{ - */ - -HAL_StatusTypeDef HAL_SDEx_ConfigDMAMultiBuffer(SD_HandleTypeDef *hsd, uint32_t *pDataBuffer0, uint32_t *pDataBuffer1, - uint32_t BufferSize); -HAL_StatusTypeDef HAL_SDEx_ReadBlocksDMAMultiBuffer(SD_HandleTypeDef *hsd, uint32_t BlockAdd, uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_SDEx_WriteBlocksDMAMultiBuffer(SD_HandleTypeDef *hsd, uint32_t BlockAdd, uint32_t NumberOfBlocks); -HAL_StatusTypeDef HAL_SDEx_ChangeDMABuffer(SD_HandleTypeDef *hsd, HAL_SDEx_DMABuffer_MemoryTypeDef Buffer, - uint32_t *pDataBuffer); - -void HAL_SDEx_Read_DMADoubleBuf0CpltCallback(SD_HandleTypeDef *hsd); -void HAL_SDEx_Read_DMADoubleBuf1CpltCallback(SD_HandleTypeDef *hsd); -void HAL_SDEx_Write_DMADoubleBuf0CpltCallback(SD_HandleTypeDef *hsd); -void HAL_SDEx_Write_DMADoubleBuf1CpltCallback(SD_HandleTypeDef *hsd); - -/** - * @} - */ - -/** - * @} - */ - -/* Private types -------------------------------------------------------------*/ -/* Private defines -----------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -/* Private constants ---------------------------------------------------------*/ -/* Private macros ------------------------------------------------------------*/ -/* Private functions prototypes ----------------------------------------------*/ -/* Private functions ---------------------------------------------------------*/ - -/** - * @} - */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ -#ifdef __cplusplus -} -#endif - - -#endif /* stm32h7xx_HAL_SD_EX_H */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_delayblock.h b/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_delayblock.h deleted file mode 100644 index 4733bc7..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_delayblock.h +++ /dev/null @@ -1,93 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_ll_delayblock.h - * @author MCD Application Team - * @brief Header file of Delay Block module. - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - */ - -/* Define to prevent recursive inclusion -------------------------------------*/ -#ifndef STM32H7xx_LL_DLYB_H -#define STM32H7xx_LL_DLYB_H - -#ifdef __cplusplus - extern "C" { -#endif - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal_def.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ - -/** @addtogroup DELAYBLOCK_LL - * @{ - */ - -/* Exported types ------------------------------------------------------------*/ -/** @defgroup DELAYBLOCK_LL_Exported_Types DELAYBLOCK_LL Exported Types - * @{ - */ - - -/** - * @} - */ - -/* Exported constants --------------------------------------------------------*/ -/** @defgroup DLYB_Exported_Constants Delay Block Exported Constants - * @{ - */ - - -#define DLYB_MAX_UNIT ((uint32_t)0x00000080U) /*!< Max UNIT value (128) */ -#define DLYB_MAX_SELECT ((uint32_t)0x0000000CU) /*!< Max SELECT value (12) */ - -/** - * @} - */ - -/** @addtogroup DelayBlock_LL_Exported_Functions - * @{ - */ - -/* Peripheral Control functions ************************************************/ -/** @addtogroup HAL_DELAY_LL_Group1 - * @{ - */ -HAL_StatusTypeDef DelayBlock_Enable(DLYB_TypeDef *DLYBx); -HAL_StatusTypeDef DelayBlock_Disable(DLYB_TypeDef *DLYBx); -HAL_StatusTypeDef DelayBlock_Configure(DLYB_TypeDef *DLYBx, uint32_t PhaseSel, uint32_t Units); - -/** - * @} - */ - -/** - * @} - */ - -/** - * @} - */ - - /** - * @} - */ -#ifdef __cplusplus -} -#endif - -#endif /* STM32H7xx_LL_DLYB_H */ - diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_sdmmc.h b/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_sdmmc.h deleted file mode 100644 index 9887fe0..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_ll_sdmmc.h +++ /dev/null @@ -1,1284 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_ll_sdmmc.h - * @author MCD Application Team - * @brief Header file of SDMMC HAL module. - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - */ - -/* Define to prevent recursive inclusion -------------------------------------*/ -#ifndef STM32H7xx_LL_SDMMC_H -#define STM32H7xx_LL_SDMMC_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal_def.h" - -/** @addtogroup STM32H7xx_Driver - * @{ - */ -#if defined (SDMMC1) || defined (SDMMC2) -/** @addtogroup SDMMC_LL - * @{ - */ - -/* Exported types ------------------------------------------------------------*/ -/** @defgroup SDMMC_LL_Exported_Types SDMMC_LL Exported Types - * @{ - */ - -/** - * @brief SDMMC Configuration Structure definition - */ -typedef struct -{ - uint32_t ClockEdge; /*!< Specifies the SDMMC_CCK clock transition on which Data and Command change. - This parameter can be a value of @ref SDMMC_LL_Clock_Edge */ - - uint32_t ClockPowerSave; /*!< Specifies whether SDMMC Clock output is enabled or - disabled when the bus is idle. - This parameter can be a value of @ref SDMMC_LL_Clock_Power_Save */ - - uint32_t BusWide; /*!< Specifies the SDMMC bus width. - This parameter can be a value of @ref SDMMC_LL_Bus_Wide */ - - uint32_t HardwareFlowControl; /*!< Specifies whether the SDMMC hardware flow control is enabled or disabled. - This parameter can be a value of @ref SDMMC_LL_Hardware_Flow_Control */ - - uint32_t ClockDiv; /*!< Specifies the clock frequency of the SDMMC controller. - This parameter can be a value between Min_Data = 0 and Max_Data = 1023 */ - -#if (USE_SD_TRANSCEIVER != 0U) || (USE_SDIO_TRANSCEIVER != 0U) - uint32_t TranceiverPresent; /*!< Specifies if there is a 1V8 Transceiver/Switcher. - This parameter can be a value of @ref SDMMC_LL_TRANSCEIVER_PRESENT */ -#endif /* USE_SD_TRANSCEIVER || USE_SDIO_TRANSCEIVER */ -} SDMMC_InitTypeDef; - - -/** - * @brief SDMMC Command Control structure - */ -typedef struct -{ - uint32_t Argument; /*!< Specifies the SDMMC command argument which is sent - to a card as part of a command message. If a command - contains an argument, it must be loaded into this register - before writing the command to the command register. */ - - uint32_t CmdIndex; /*!< Specifies the SDMMC command index. It must be Min_Data = 0 and - Max_Data = 64 */ - - uint32_t Response; /*!< Specifies the SDMMC response type. - This parameter can be a value of @ref SDMMC_LL_Response_Type */ - - uint32_t WaitForInterrupt; /*!< Specifies whether SDMMC wait for interrupt request is - enabled or disabled. - This parameter can be a value of @ref SDMMC_LL_Wait_Interrupt_State */ - - uint32_t CPSM; /*!< Specifies whether SDMMC Command path state machine (CPSM) - is enabled or disabled. - This parameter can be a value of @ref SDMMC_LL_CPSM_State */ -} SDMMC_CmdInitTypeDef; - - -/** - * @brief SDMMC Data Control structure - */ -typedef struct -{ - uint32_t DataTimeOut; /*!< Specifies the data timeout period in card bus clock periods. */ - - uint32_t DataLength; /*!< Specifies the number of data bytes to be transferred. */ - - uint32_t DataBlockSize; /*!< Specifies the data block size for block transfer. - This parameter can be a value of @ref SDMMC_LL_Data_Block_Size */ - - uint32_t TransferDir; /*!< Specifies the data transfer direction, whether the transfer - is a read or write. - This parameter can be a value of @ref SDMMC_LL_Transfer_Direction */ - - uint32_t TransferMode; /*!< Specifies whether data transfer is in stream or block mode. - This parameter can be a value of @ref SDMMC_LL_Transfer_Type */ - - uint32_t DPSM; /*!< Specifies whether SDMMC Data path state machine (DPSM) - is enabled or disabled. - This parameter can be a value of @ref SDMMC_LL_DPSM_State */ -} SDMMC_DataInitTypeDef; - -/** - * @} - */ - -/* Exported constants --------------------------------------------------------*/ -/** @defgroup SDMMC_LL_Exported_Constants SDMMC_LL Exported Constants - * @{ - */ -#define SDMMC_ERROR_NONE ((uint32_t)0x00000000U) /*!< No error */ -#define SDMMC_ERROR_CMD_CRC_FAIL ((uint32_t)0x00000001U) /*!< Command response received (but CRC check failed) */ -#define SDMMC_ERROR_DATA_CRC_FAIL ((uint32_t)0x00000002U) /*!< Data block sent/received (CRC check failed) */ -#define SDMMC_ERROR_CMD_RSP_TIMEOUT ((uint32_t)0x00000004U) /*!< Command response timeout */ -#define SDMMC_ERROR_DATA_TIMEOUT ((uint32_t)0x00000008U) /*!< Data timeout */ -#define SDMMC_ERROR_TX_UNDERRUN ((uint32_t)0x00000010U) /*!< Transmit FIFO underrun */ -#define SDMMC_ERROR_RX_OVERRUN ((uint32_t)0x00000020U) /*!< Receive FIFO overrun */ -#define SDMMC_ERROR_ADDR_MISALIGNED ((uint32_t)0x00000040U) /*!< Misaligned address */ -#define SDMMC_ERROR_BLOCK_LEN_ERR ((uint32_t)0x00000080U) /*!< Transferred block length is not allowed for the card or the number of transferred bytes does not match the block length */ -#define SDMMC_ERROR_ERASE_SEQ_ERR ((uint32_t)0x00000100U) /*!< An error in the sequence of erase command occurs */ -#define SDMMC_ERROR_BAD_ERASE_PARAM ((uint32_t)0x00000200U) /*!< An invalid selection for erase groups */ -#define SDMMC_ERROR_WRITE_PROT_VIOLATION ((uint32_t)0x00000400U) /*!< Attempt to program a write protect block */ -#define SDMMC_ERROR_LOCK_UNLOCK_FAILED ((uint32_t)0x00000800U) /*!< Sequence or password error has been detected in unlock command or if there was an attempt to access a locked card */ -#define SDMMC_ERROR_COM_CRC_FAILED ((uint32_t)0x00001000U) /*!< CRC check of the previous command failed */ -#define SDMMC_ERROR_ILLEGAL_CMD ((uint32_t)0x00002000U) /*!< Command is not legal for the card state */ -#define SDMMC_ERROR_CARD_ECC_FAILED ((uint32_t)0x00004000U) /*!< Card internal ECC was applied but failed to correct the data */ -#define SDMMC_ERROR_CC_ERR ((uint32_t)0x00008000U) /*!< Internal card controller error */ -#define SDMMC_ERROR_GENERAL_UNKNOWN_ERR ((uint32_t)0x00010000U) /*!< General or unknown error */ -#define SDMMC_ERROR_STREAM_READ_UNDERRUN ((uint32_t)0x00020000U) /*!< The card could not sustain data reading in stream rmode */ -#define SDMMC_ERROR_STREAM_WRITE_OVERRUN ((uint32_t)0x00040000U) /*!< The card could not sustain data programming in stream mode */ -#define SDMMC_ERROR_CID_CSD_OVERWRITE ((uint32_t)0x00080000U) /*!< CID/CSD overwrite error */ -#define SDMMC_ERROR_WP_ERASE_SKIP ((uint32_t)0x00100000U) /*!< Only partial address space was erased */ -#define SDMMC_ERROR_CARD_ECC_DISABLED ((uint32_t)0x00200000U) /*!< Command has been executed without using internal ECC */ -#define SDMMC_ERROR_ERASE_RESET ((uint32_t)0x00400000U) /*!< Erase sequence was cleared before executing because an out of erase sequence command was received */ -#define SDMMC_ERROR_AKE_SEQ_ERR ((uint32_t)0x00800000U) /*!< Error in sequence of authentication */ -#define SDMMC_ERROR_INVALID_VOLTRANGE ((uint32_t)0x01000000U) /*!< Error in case of invalid voltage range */ -#define SDMMC_ERROR_ADDR_OUT_OF_RANGE ((uint32_t)0x02000000U) /*!< Error when addressed block is out of range */ -#define SDMMC_ERROR_REQUEST_NOT_APPLICABLE ((uint32_t)0x04000000U) /*!< Error when command request is not applicable */ -#define SDMMC_ERROR_INVALID_PARAMETER ((uint32_t)0x08000000U) /*!< the used parameter is not valid */ -#define SDMMC_ERROR_UNSUPPORTED_FEATURE ((uint32_t)0x10000000U) /*!< Error when feature is not insupported */ -#define SDMMC_ERROR_BUSY ((uint32_t)0x20000000U) /*!< Error when transfer process is busy */ -#define SDMMC_ERROR_DMA ((uint32_t)0x40000000U) /*!< Error while DMA transfer */ -#define SDMMC_ERROR_TIMEOUT ((uint32_t)0x80000000U) /*!< Timeout error */ - -/** - * @brief Masks for R5 Response - */ -/** this is the reserved for future use in spec RFU */ -#define SDMMC_SDIO_R5_ERROR ((uint32_t)0x00000400U) -/** Out of range error */ -#define SDMMC_SDIO_R5_OUT_OF_RANGE ((uint32_t)0x00000100U) -/** Invalid function number */ -#define SDMMC_SDIO_R5_INVALID_FUNCTION_NUMBER ((uint32_t)0x00000200U) -/** General or an unknown error */ -#define SDMMC_SDIO_R5_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00000800U) -/** SDIO Card current state - * 00=DIS (card not selected) - * 01=CMD (data line free) - * 10=TRN (transfer on data lines) */ -#define SDMMC_SDIO_R5_IO_CURRENT_STATE ((uint32_t)0x00003000U) -/** Illegal command error */ -#define SDMMC_SDIO_R5_ILLEGAL_CMD ((uint32_t)0x00004000U) -/** CRC check of previous cmd failed */ -#define SDMMC_SDIO_R5_COM_CRC_FAILED ((uint32_t)0x00008000U) - -#define SDMMC_SDIO_R5_ERRORBITS (SDMMC_SDIO_R5_COM_CRC_FAILED | \ - SDMMC_SDIO_R5_ILLEGAL_CMD | \ - SDMMC_SDIO_R5_GENERAL_UNKNOWN_ERROR | \ - SDMMC_SDIO_R5_INVALID_FUNCTION_NUMBER | \ - SDMMC_SDIO_R5_OUT_OF_RANGE) -/** - * @brief SDIO_CMD53_MODE - */ -#define SDMMC_SDIO_MODE_BYTE 0x00U /*!< Byte Mode */ -#define SDMMC_SDIO_MODE_BLOCK 0x01U /*!< Block Mode */ - -/** - * @brief SDIO_CMD53_OP_CODE - */ -#define SDMMC_SDIO_NO_INC 0x00U /*!< No auto indentation */ -#define SDMMC_SDIO_AUTO_INC 0x01U /*!< Auto indentation */ - -/** - * @brief SDIO_CMD53_RAW - */ -#define SDMMC_SDIO_WO 0x00U /*!< Write only Flag */ -#define SDMMC_SDIO_RAW 0x01U /*!< Read after write Flag */ - -/** - * @brief SDMMC Commands Index - */ -#define SDMMC_CMD_GO_IDLE_STATE 0U /*!< Resets the SD memory card. */ -#define SDMMC_CMD_SEND_OP_COND 1U /*!< Sends host capacity support information and activates the card's initialization process. */ -#define SDMMC_CMD_ALL_SEND_CID 2U /*!< Asks any card connected to the host to send the CID numbers on the CMD line. */ -#define SDMMC_CMD_SET_REL_ADDR 3U /*!< Asks the card to publish a new relative address (RCA). */ -#define SDMMC_CMD_SET_DSR 4U /*!< Programs the DSR of all cards. */ -#define SDMMC_CMD_SDMMC_SEN_OP_COND 5U /*!< Sends host capacity support information (HCS) and asks the accessed card to send its operating condition register (OCR) content in the response on the CMD line.*/ -#define SDMMC_CMD_HS_SWITCH 6U /*!< Checks switchable function (mode 0) and switch card function (mode 1). */ -#define SDMMC_CMD_SEL_DESEL_CARD 7U /*!< Selects the card by its own relative address and gets deselected by any other address */ -#define SDMMC_CMD_HS_SEND_EXT_CSD 8U /*!< Sends SD Memory Card interface condition, which includes host supply voltage information and asks the card whether card supports voltage. */ -#define SDMMC_CMD_SEND_CSD 9U /*!< Addressed card sends its card specific data (CSD) on the CMD line. */ -#define SDMMC_CMD_SEND_CID 10U /*!< Addressed card sends its card identification (CID) on the CMD line. */ -#define SDMMC_CMD_VOLTAGE_SWITCH 11U /*!< SD card Voltage switch to 1.8V mode. */ -#define SDMMC_CMD_STOP_TRANSMISSION 12U /*!< Forces the card to stop transmission. */ -#define SDMMC_CMD_SEND_STATUS 13U /*!< Addressed card sends its status register. */ -#define SDMMC_CMD_HS_BUSTEST_READ 14U /*!< Reserved */ -#define SDMMC_CMD_GO_INACTIVE_STATE 15U /*!< Sends an addressed card into the inactive state. */ -#define SDMMC_CMD_SET_BLOCKLEN 16U /*!< Sets the block length (in bytes for SDSC) for all following block commands (read, write, lock). Default block length is fixed to 512 Bytes. Not effective */ -/*!< for SDHS and SDXC. */ -#define SDMMC_CMD_READ_SINGLE_BLOCK 17U /*!< Reads single block of size selected by SET_BLOCKLEN in case of SDSC, and a block of fixed 512 bytes in case of SDHC and SDXC. */ -#define SDMMC_CMD_READ_MULT_BLOCK 18U /*!< Continuously transfers data blocks from card to host until interrupted by STOP_TRANSMISSION command. */ -#define SDMMC_CMD_HS_BUSTEST_WRITE 19U /*!< 64 bytes tuning pattern is sent for SDR50 and SDR104. */ -#define SDMMC_CMD_WRITE_DAT_UNTIL_STOP 20U /*!< Speed class control command. */ -#define SDMMC_CMD_SET_BLOCK_COUNT 23U /*!< Specify block count for CMD18 and CMD25. */ -#define SDMMC_CMD_WRITE_SINGLE_BLOCK 24U /*!< Writes single block of size selected by SET_BLOCKLEN in case of SDSC, and a block of fixed 512 bytes in case of SDHC and SDXC. */ -#define SDMMC_CMD_WRITE_MULT_BLOCK 25U /*!< Continuously writes blocks of data until a STOP_TRANSMISSION follows. */ -#define SDMMC_CMD_PROG_CID 26U /*!< Reserved for manufacturers. */ -#define SDMMC_CMD_PROG_CSD 27U /*!< Programming of the programmable bits of the CSD. */ -#define SDMMC_CMD_SET_WRITE_PROT 28U /*!< Sets the write protection bit of the addressed group. */ -#define SDMMC_CMD_CLR_WRITE_PROT 29U /*!< Clears the write protection bit of the addressed group. */ -#define SDMMC_CMD_SEND_WRITE_PROT 30U /*!< Asks the card to send the status of the write protection bits. */ -#define SDMMC_CMD_SD_ERASE_GRP_START 32U /*!< Sets the address of the first write block to be erased. (For SD card only). */ -#define SDMMC_CMD_SD_ERASE_GRP_END 33U /*!< Sets the address of the last write block of the continuous range to be erased. */ -#define SDMMC_CMD_ERASE_GRP_START 35U /*!< Sets the address of the first write block to be erased. Reserved for each command system set by switch function command (CMD6). */ -#define SDMMC_CMD_ERASE_GRP_END 36U /*!< Sets the address of the last write block of the continuous range to be erased. Reserved for each command system set by switch function command (CMD6). */ -#define SDMMC_CMD_ERASE 38U /*!< Reserved for SD security applications. */ -#define SDMMC_CMD_FAST_IO 39U /*!< SD card doesn't support it (Reserved). */ -#define SDMMC_CMD_GO_IRQ_STATE 40U /*!< SD card doesn't support it (Reserved). */ -#define SDMMC_CMD_LOCK_UNLOCK 42U /*!< Sets/resets the password or lock/unlock the card. The size of the data block is set by the SET_BLOCK_LEN command. */ -#define SDMMC_CMD_APP_CMD 55U /*!< Indicates to the card that the next command is an application specific command rather than a standard command. */ -#define SDMMC_CMD_GEN_CMD 56U /*!< Used either to transfer a data block to the card or to get a data block from the card for general purpose/application specific commands. */ -#define SDMMC_CMD_NO_CMD 64U /*!< No command */ - -/** - * @brief Following commands are SD Card Specific commands. - * SDMMC_APP_CMD should be sent before sending these commands. - */ -#define SDMMC_CMD_APP_SD_SET_BUSWIDTH 6U /*!< (ACMD6) Defines the data bus width to be used for data transfer. The allowed data bus widths are given in SCR register. */ -#define SDMMC_CMD_SD_APP_STATUS 13U /*!< (ACMD13) Sends the SD status. */ -#define SDMMC_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS 22U /*!< (ACMD22) Sends the number of the written (without errors) write blocks. Responds with 32bit+CRC data block. */ -#define SDMMC_CMD_SD_APP_OP_COND 41U /*!< (ACMD41) Sends host capacity support information (HCS) and asks the accessed card to send its operating condition register (OCR) content in the response on the CMD line. */ -#define SDMMC_CMD_SD_APP_SET_CLR_CARD_DETECT 42U /*!< (ACMD42) Connect/Disconnect the 50 KOhm pull-up resistor on CD/DAT3 (pin 1) of the card */ -#define SDMMC_CMD_SD_APP_SEND_SCR 51U /*!< Reads the SD Configuration Register (SCR). */ -#define SDMMC_CMD_SDMMC_RW_DIRECT 52U /*!< For SD I/O card only, reserved for security specification. */ -#define SDMMC_CMD_SDMMC_RW_EXTENDED 53U /*!< For SD I/O card only, reserved for security specification. */ - -/** - * @brief Following commands are MMC Specific commands. - */ -#define SDMMC_CMD_MMC_SLEEP_AWAKE 5U /*!< Toggle the device between Sleep state and Standby state. */ - -/** - * @brief Following commands are SD Card Specific security commands. - * SDMMC_CMD_APP_CMD should be sent before sending these commands. - */ -#define SDMMC_CMD_SD_APP_GET_MKB 43U -#define SDMMC_CMD_SD_APP_GET_MID 44U -#define SDMMC_CMD_SD_APP_SET_CER_RN1 45U -#define SDMMC_CMD_SD_APP_GET_CER_RN2 46U -#define SDMMC_CMD_SD_APP_SET_CER_RES2 47U -#define SDMMC_CMD_SD_APP_GET_CER_RES1 48U -#define SDMMC_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK 18U -#define SDMMC_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK 25U -#define SDMMC_CMD_SD_APP_SECURE_ERASE 38U -#define SDMMC_CMD_SD_APP_CHANGE_SECURE_AREA 49U -#define SDMMC_CMD_SD_APP_SECURE_WRITE_MKB 48U - -/** - * @brief Masks for errors Card Status R1 (OCR Register) - */ -#define SDMMC_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000U) -#define SDMMC_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000U) -#define SDMMC_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000U) -#define SDMMC_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000U) -#define SDMMC_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000U) -#define SDMMC_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000U) -#define SDMMC_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000U) -#define SDMMC_OCR_COM_CRC_FAILED ((uint32_t)0x00800000U) -#define SDMMC_OCR_ILLEGAL_CMD ((uint32_t)0x00400000U) -#define SDMMC_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000U) -#define SDMMC_OCR_CC_ERROR ((uint32_t)0x00100000U) -#define SDMMC_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000U) -#define SDMMC_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000U) -#define SDMMC_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000U) -#define SDMMC_OCR_CID_CSD_OVERWRITE ((uint32_t)0x00010000U) -#define SDMMC_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000U) -#define SDMMC_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000U) -#define SDMMC_OCR_ERASE_RESET ((uint32_t)0x00002000U) -#define SDMMC_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008U) -#define SDMMC_OCR_ERRORBITS ((uint32_t)0xFDFFE008U) - -/** - * @brief Masks for R6 Response - */ -#define SDMMC_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000U) -#define SDMMC_R6_ILLEGAL_CMD ((uint32_t)0x00004000U) -#define SDMMC_R6_COM_CRC_FAILED ((uint32_t)0x00008000U) - -#define SDMMC_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000U) -#define SDMMC_HIGH_CAPACITY ((uint32_t)0x40000000U) -#define SDMMC_STD_CAPACITY ((uint32_t)0x00000000U) -#define SDMMC_CHECK_PATTERN ((uint32_t)0x000001AAU) -#define SD_SWITCH_1_8V_CAPACITY ((uint32_t)0x01000000U) -#define SDMMC_DDR50_SWITCH_PATTERN ((uint32_t)0x80FFFF04U) -#define SDMMC_SDR104_SWITCH_PATTERN ((uint32_t)0x80FF1F03U) -#define SDMMC_SDR50_SWITCH_PATTERN ((uint32_t)0x80FF1F02U) -#define SDMMC_SDR25_SWITCH_PATTERN ((uint32_t)0x80FFFF01U) -#define SDMMC_SDR12_SWITCH_PATTERN ((uint32_t)0x80FFFF00U) - -#define SDMMC_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFFU) - -#define SDMMC_MAX_TRIAL ((uint32_t)0x0000FFFFU) - -#define SDMMC_ALLZERO ((uint32_t)0x00000000U) - -#define SDMMC_WIDE_BUS_SUPPORT ((uint32_t)0x00040000U) -#define SDMMC_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000U) -#define SDMMC_CARD_LOCKED ((uint32_t)0x02000000U) - -#ifndef SDMMC_DATATIMEOUT /*Hardware Data Timeout (cycles) */ -#define SDMMC_DATATIMEOUT ((uint32_t)0xFFFFFFFFU) -#endif /* SDMMC_DATATIMEOUT */ - -#ifndef SDMMC_SWDATATIMEOUT /*Software Data Timeout (ms) */ -#define SDMMC_SWDATATIMEOUT ((uint32_t)0xFFFFFFFFU) -#endif /* SDMMC_SWDATATIMEOUT */ - -#define SDMMC_0TO7BITS ((uint32_t)0x000000FFU) -#define SDMMC_8TO15BITS ((uint32_t)0x0000FF00U) -#define SDMMC_16TO23BITS ((uint32_t)0x00FF0000U) -#define SDMMC_24TO31BITS ((uint32_t)0xFF000000U) -#define SDMMC_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFFU) - -#define SDMMC_HALFFIFO ((uint32_t)0x00000008U) -#define SDMMC_HALFFIFOBYTES ((uint32_t)0x00000020U) - -/* SDMMC FIFO Size */ -#define SDMMC_FIFO_SIZE 32U -/** - * @brief Command Class supported - */ -#define SDMMC_CCCC_ERASE ((uint32_t)0x00000020U) - -#define SDMMC_CMDTIMEOUT ((uint32_t)5000U) /* Command send and response timeout */ -#define SDMMC_MAXERASETIMEOUT ((uint32_t)63000U) /* Max erase Timeout 63 s */ -#define SDMMC_STOPTRANSFERTIMEOUT ((uint32_t)100000000U) /* Timeout for STOP TRANSMISSION command */ - -/** @defgroup SDMMC_LL_Clock_Edge Clock Edge - * @{ - */ -#define SDMMC_CLOCK_EDGE_RISING ((uint32_t)0x00000000U) -#define SDMMC_CLOCK_EDGE_FALLING SDMMC_CLKCR_NEGEDGE - -#define IS_SDMMC_CLOCK_EDGE(EDGE) (((EDGE) == SDMMC_CLOCK_EDGE_RISING) || \ - ((EDGE) == SDMMC_CLOCK_EDGE_FALLING)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Clock_Power_Save Clock Power Saving - * @{ - */ -#define SDMMC_CLOCK_POWER_SAVE_DISABLE ((uint32_t)0x00000000U) -#define SDMMC_CLOCK_POWER_SAVE_ENABLE SDMMC_CLKCR_PWRSAV - -#define IS_SDMMC_CLOCK_POWER_SAVE(SAVE) (((SAVE) == SDMMC_CLOCK_POWER_SAVE_DISABLE) || \ - ((SAVE) == SDMMC_CLOCK_POWER_SAVE_ENABLE)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Bus_Wide Bus Width - * @{ - */ -#define SDMMC_BUS_WIDE_1B ((uint32_t)0x00000000U) -#define SDMMC_BUS_WIDE_4B SDMMC_CLKCR_WIDBUS_0 -#define SDMMC_BUS_WIDE_8B SDMMC_CLKCR_WIDBUS_1 - -#define IS_SDMMC_BUS_WIDE(WIDE) (((WIDE) == SDMMC_BUS_WIDE_1B) || \ - ((WIDE) == SDMMC_BUS_WIDE_4B) || \ - ((WIDE) == SDMMC_BUS_WIDE_8B)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Speed_Mode - * @{ - */ -#define SDMMC_SPEED_MODE_AUTO ((uint32_t)0x00000000U) -#define SDMMC_SPEED_MODE_DEFAULT ((uint32_t)0x00000001U) -#define SDMMC_SPEED_MODE_HIGH ((uint32_t)0x00000002U) -#define SDMMC_SPEED_MODE_ULTRA ((uint32_t)0x00000003U) -#define SDMMC_SPEED_MODE_ULTRA_SDR104 SDMMC_SPEED_MODE_ULTRA -#define SDMMC_SPEED_MODE_DDR ((uint32_t)0x00000004U) -#define SDMMC_SPEED_MODE_ULTRA_SDR50 ((uint32_t)0x00000005U) - -#define IS_SDMMC_SPEED_MODE(MODE) (((MODE) == SDMMC_SPEED_MODE_AUTO) || \ - ((MODE) == SDMMC_SPEED_MODE_DEFAULT) || \ - ((MODE) == SDMMC_SPEED_MODE_HIGH) || \ - ((MODE) == SDMMC_SPEED_MODE_ULTRA) || \ - ((MODE) == SDMMC_SPEED_MODE_ULTRA_SDR50) || \ - ((MODE) == SDMMC_SPEED_MODE_DDR)) - -/** - * @} - */ - -/** @defgroup SDMMC_LL_Hardware_Flow_Control Hardware Flow Control - * @{ - */ -#define SDMMC_HARDWARE_FLOW_CONTROL_DISABLE ((uint32_t)0x00000000U) -#define SDMMC_HARDWARE_FLOW_CONTROL_ENABLE SDMMC_CLKCR_HWFC_EN - -#define IS_SDMMC_HARDWARE_FLOW_CONTROL(CONTROL) (((CONTROL) == SDMMC_HARDWARE_FLOW_CONTROL_DISABLE) || \ - ((CONTROL) == SDMMC_HARDWARE_FLOW_CONTROL_ENABLE)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Clock_Division Clock Division - * @{ - */ -/* SDMMC_CK frequency = SDMMCCLK / [2 * CLKDIV] */ -#define IS_SDMMC_CLKDIV(DIV) ((DIV) < 0x400U) -/** - * @} - */ - -/** @defgroup SDMMC_LL_TRANSCEIVER_PRESENT Transceiver Present - * @{ - */ -#define SDMMC_TRANSCEIVER_UNKNOWN ((uint32_t)0x00000000U) -#define SDMMC_TRANSCEIVER_NOT_PRESENT ((uint32_t)0x00000001U) -#define SDMMC_TRANSCEIVER_PRESENT ((uint32_t)0x00000002U) - -/** - * @} - */ - -/** @defgroup SDMMC_LL_Command_Index Command Index - * @{ - */ -#define IS_SDMMC_CMD_INDEX(INDEX) ((INDEX) < 0x40U) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Response_Type Response Type - * @{ - */ -#define SDMMC_RESPONSE_NO ((uint32_t)0x00000000U) -#define SDMMC_RESPONSE_SHORT SDMMC_CMD_WAITRESP_0 -#define SDMMC_RESPONSE_LONG SDMMC_CMD_WAITRESP - -#define IS_SDMMC_RESPONSE(RESPONSE) (((RESPONSE) == SDMMC_RESPONSE_NO) || \ - ((RESPONSE) == SDMMC_RESPONSE_SHORT) || \ - ((RESPONSE) == SDMMC_RESPONSE_LONG)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Wait_Interrupt_State Wait Interrupt - * @{ - */ -#define SDMMC_WAIT_NO ((uint32_t)0x00000000U) -#define SDMMC_WAIT_IT SDMMC_CMD_WAITINT -#define SDMMC_WAIT_PEND SDMMC_CMD_WAITPEND - -#define IS_SDMMC_WAIT(WAIT) (((WAIT) == SDMMC_WAIT_NO) || \ - ((WAIT) == SDMMC_WAIT_IT) || \ - ((WAIT) == SDMMC_WAIT_PEND)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_CPSM_State CPSM State - * @{ - */ -#define SDMMC_CPSM_DISABLE ((uint32_t)0x00000000U) -#define SDMMC_CPSM_ENABLE SDMMC_CMD_CPSMEN - -#define IS_SDMMC_CPSM(CPSM) (((CPSM) == SDMMC_CPSM_DISABLE) || \ - ((CPSM) == SDMMC_CPSM_ENABLE)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Response_Registers Response Register - * @{ - */ -#define SDMMC_RESP1 ((uint32_t)0x00000000U) -#define SDMMC_RESP2 ((uint32_t)0x00000004U) -#define SDMMC_RESP3 ((uint32_t)0x00000008U) -#define SDMMC_RESP4 ((uint32_t)0x0000000CU) - -#define IS_SDMMC_RESP(RESP) (((RESP) == SDMMC_RESP1) || \ - ((RESP) == SDMMC_RESP2) || \ - ((RESP) == SDMMC_RESP3) || \ - ((RESP) == SDMMC_RESP4)) - -/** @defgroup SDMMC_Internal_DMA_Mode SDMMC Internal DMA Mode - * @{ - */ -#define SDMMC_DISABLE_IDMA ((uint32_t)0x00000000) -#define SDMMC_ENABLE_IDMA_SINGLE_BUFF (SDMMC_IDMA_IDMAEN) -#define SDMMC_ENABLE_IDMA_DOUBLE_BUFF0 (SDMMC_IDMA_IDMAEN | SDMMC_IDMA_IDMABMODE) -#define SDMMC_ENABLE_IDMA_DOUBLE_BUFF1 (SDMMC_IDMA_IDMAEN | SDMMC_IDMA_IDMABMODE | SDMMC_IDMA_IDMABACT) - -/** - * @} - */ - -/** @defgroup SDMMC_LL_Data_Length Data Length - * @{ - */ -#define IS_SDMMC_DATA_LENGTH(LENGTH) ((LENGTH) <= 0x01FFFFFFU) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Data_Block_Size Data Block Size - * @{ - */ -#define SDMMC_DATABLOCK_SIZE_1B ((uint32_t)0x00000000U) -#define SDMMC_DATABLOCK_SIZE_2B SDMMC_DCTRL_DBLOCKSIZE_0 -#define SDMMC_DATABLOCK_SIZE_4B SDMMC_DCTRL_DBLOCKSIZE_1 -#define SDMMC_DATABLOCK_SIZE_8B (SDMMC_DCTRL_DBLOCKSIZE_0|SDMMC_DCTRL_DBLOCKSIZE_1) -#define SDMMC_DATABLOCK_SIZE_16B SDMMC_DCTRL_DBLOCKSIZE_2 -#define SDMMC_DATABLOCK_SIZE_32B (SDMMC_DCTRL_DBLOCKSIZE_0|SDMMC_DCTRL_DBLOCKSIZE_2) -#define SDMMC_DATABLOCK_SIZE_64B (SDMMC_DCTRL_DBLOCKSIZE_1|SDMMC_DCTRL_DBLOCKSIZE_2) -#define SDMMC_DATABLOCK_SIZE_128B (SDMMC_DCTRL_DBLOCKSIZE_0| \ - SDMMC_DCTRL_DBLOCKSIZE_1|SDMMC_DCTRL_DBLOCKSIZE_2) -#define SDMMC_DATABLOCK_SIZE_256B SDMMC_DCTRL_DBLOCKSIZE_3 -#define SDMMC_DATABLOCK_SIZE_512B (SDMMC_DCTRL_DBLOCKSIZE_0|SDMMC_DCTRL_DBLOCKSIZE_3) -#define SDMMC_DATABLOCK_SIZE_1024B (SDMMC_DCTRL_DBLOCKSIZE_1|SDMMC_DCTRL_DBLOCKSIZE_3) -#define SDMMC_DATABLOCK_SIZE_2048B (SDMMC_DCTRL_DBLOCKSIZE_0| \ - SDMMC_DCTRL_DBLOCKSIZE_1|SDMMC_DCTRL_DBLOCKSIZE_3) -#define SDMMC_DATABLOCK_SIZE_4096B (SDMMC_DCTRL_DBLOCKSIZE_2|SDMMC_DCTRL_DBLOCKSIZE_3) -#define SDMMC_DATABLOCK_SIZE_8192B (SDMMC_DCTRL_DBLOCKSIZE_0| \ - SDMMC_DCTRL_DBLOCKSIZE_2|SDMMC_DCTRL_DBLOCKSIZE_3) -#define SDMMC_DATABLOCK_SIZE_16384B (SDMMC_DCTRL_DBLOCKSIZE_1| \ - SDMMC_DCTRL_DBLOCKSIZE_2|SDMMC_DCTRL_DBLOCKSIZE_3) - -#define IS_SDMMC_BLOCK_SIZE(SIZE) (((SIZE) == SDMMC_DATABLOCK_SIZE_1B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_2B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_4B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_8B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_16B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_32B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_64B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_128B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_256B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_512B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_1024B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_2048B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_4096B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_8192B) || \ - ((SIZE) == SDMMC_DATABLOCK_SIZE_16384B)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Transfer_Direction Transfer Direction - * @{ - */ -#define SDMMC_TRANSFER_DIR_TO_CARD ((uint32_t)0x00000000U) -#define SDMMC_TRANSFER_DIR_TO_SDMMC SDMMC_DCTRL_DTDIR - -#define IS_SDMMC_TRANSFER_DIR(DIR) (((DIR) == SDMMC_TRANSFER_DIR_TO_CARD) || \ - ((DIR) == SDMMC_TRANSFER_DIR_TO_SDMMC)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Transfer_Type Transfer Type - * @{ - */ -#define SDMMC_TRANSFER_MODE_BLOCK ((uint32_t)0x00000000U) -#define SDMMC_TRANSFER_MODE_SDIO SDMMC_DCTRL_DTMODE_0 -#define SDMMC_TRANSFER_MODE_STREAM SDMMC_DCTRL_DTMODE_1 - -#define IS_SDMMC_TRANSFER_MODE(MODE) (((MODE) == SDMMC_TRANSFER_MODE_BLOCK) || \ - ((MODE) == SDMMC_TRANSFER_MODE_SDIO) || \ - ((MODE) == SDMMC_TRANSFER_MODE_STREAM)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_DPSM_State DPSM State - * @{ - */ -#define SDMMC_DPSM_DISABLE ((uint32_t)0x00000000U) -#define SDMMC_DPSM_ENABLE SDMMC_DCTRL_DTEN - -#define IS_SDMMC_DPSM(DPSM) (((DPSM) == SDMMC_DPSM_DISABLE) ||\ - ((DPSM) == SDMMC_DPSM_ENABLE)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Read_Wait_Mode Read Wait Mode - * @{ - */ -#define SDMMC_READ_WAIT_MODE_DATA2 ((uint32_t)0x00000000U) -#define SDMMC_READ_WAIT_MODE_CLK (SDMMC_DCTRL_RWMOD) - -#define IS_SDMMC_READWAIT_MODE(MODE) (((MODE) == SDMMC_READ_WAIT_MODE_CLK) || \ - ((MODE) == SDMMC_READ_WAIT_MODE_DATA2)) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Interrupt_sources Interrupt Sources - * @{ - */ -#define SDMMC_IT_CCRCFAIL SDMMC_MASK_CCRCFAILIE -#define SDMMC_IT_DCRCFAIL SDMMC_MASK_DCRCFAILIE -#define SDMMC_IT_CTIMEOUT SDMMC_MASK_CTIMEOUTIE -#define SDMMC_IT_DTIMEOUT SDMMC_MASK_DTIMEOUTIE -#define SDMMC_IT_TXUNDERR SDMMC_MASK_TXUNDERRIE -#define SDMMC_IT_RXOVERR SDMMC_MASK_RXOVERRIE -#define SDMMC_IT_CMDREND SDMMC_MASK_CMDRENDIE -#define SDMMC_IT_CMDSENT SDMMC_MASK_CMDSENTIE -#define SDMMC_IT_DATAEND SDMMC_MASK_DATAENDIE -#define SDMMC_IT_DHOLD SDMMC_MASK_DHOLDIE -#define SDMMC_IT_DBCKEND SDMMC_MASK_DBCKENDIE -#define SDMMC_IT_DABORT SDMMC_MASK_DABORTIE -#define SDMMC_IT_TXFIFOHE SDMMC_MASK_TXFIFOHEIE -#define SDMMC_IT_RXFIFOHF SDMMC_MASK_RXFIFOHFIE -#define SDMMC_IT_RXFIFOF SDMMC_MASK_RXFIFOFIE -#define SDMMC_IT_TXFIFOE SDMMC_MASK_TXFIFOEIE -#define SDMMC_IT_BUSYD0END SDMMC_MASK_BUSYD0ENDIE -#define SDMMC_IT_SDIOIT SDMMC_MASK_SDIOITIE -#define SDMMC_IT_ACKFAIL SDMMC_MASK_ACKFAILIE -#define SDMMC_IT_ACKTIMEOUT SDMMC_MASK_ACKTIMEOUTIE -#define SDMMC_IT_VSWEND SDMMC_MASK_VSWENDIE -#define SDMMC_IT_CKSTOP SDMMC_MASK_CKSTOPIE -#define SDMMC_IT_IDMABTC SDMMC_MASK_IDMABTCIE -/** - * @} - */ - -/** @defgroup SDMMC_LL_Flags Flags - * @{ - */ -#define SDMMC_FLAG_CCRCFAIL SDMMC_STA_CCRCFAIL -#define SDMMC_FLAG_DCRCFAIL SDMMC_STA_DCRCFAIL -#define SDMMC_FLAG_CTIMEOUT SDMMC_STA_CTIMEOUT -#define SDMMC_FLAG_DTIMEOUT SDMMC_STA_DTIMEOUT -#define SDMMC_FLAG_TXUNDERR SDMMC_STA_TXUNDERR -#define SDMMC_FLAG_RXOVERR SDMMC_STA_RXOVERR -#define SDMMC_FLAG_CMDREND SDMMC_STA_CMDREND -#define SDMMC_FLAG_CMDSENT SDMMC_STA_CMDSENT -#define SDMMC_FLAG_DATAEND SDMMC_STA_DATAEND -#define SDMMC_FLAG_DHOLD SDMMC_STA_DHOLD -#define SDMMC_FLAG_DBCKEND SDMMC_STA_DBCKEND -#define SDMMC_FLAG_DABORT SDMMC_STA_DABORT -#define SDMMC_FLAG_DPSMACT SDMMC_STA_DPSMACT -#define SDMMC_FLAG_CMDACT SDMMC_STA_CPSMACT -#define SDMMC_FLAG_TXFIFOHE SDMMC_STA_TXFIFOHE -#define SDMMC_FLAG_RXFIFOHF SDMMC_STA_RXFIFOHF -#define SDMMC_FLAG_TXFIFOF SDMMC_STA_TXFIFOF -#define SDMMC_FLAG_RXFIFOF SDMMC_STA_RXFIFOF -#define SDMMC_FLAG_TXFIFOE SDMMC_STA_TXFIFOE -#define SDMMC_FLAG_RXFIFOE SDMMC_STA_RXFIFOE -#define SDMMC_FLAG_BUSYD0 SDMMC_STA_BUSYD0 -#define SDMMC_FLAG_BUSYD0END SDMMC_STA_BUSYD0END -#define SDMMC_FLAG_SDIOIT SDMMC_STA_SDIOIT -#define SDMMC_FLAG_ACKFAIL SDMMC_STA_ACKFAIL -#define SDMMC_FLAG_ACKTIMEOUT SDMMC_STA_ACKTIMEOUT -#define SDMMC_FLAG_VSWEND SDMMC_STA_VSWEND -#define SDMMC_FLAG_CKSTOP SDMMC_STA_CKSTOP -#define SDMMC_FLAG_IDMATE SDMMC_STA_IDMATE -#define SDMMC_FLAG_IDMABTC SDMMC_STA_IDMABTC - -#define SDMMC_STATIC_FLAGS ((uint32_t)(SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_CTIMEOUT |\ - SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_RXOVERR |\ - SDMMC_FLAG_CMDREND | SDMMC_FLAG_CMDSENT | SDMMC_FLAG_DATAEND |\ - SDMMC_FLAG_DHOLD | SDMMC_FLAG_DBCKEND | SDMMC_FLAG_DABORT |\ - SDMMC_FLAG_BUSYD0END | SDMMC_FLAG_SDIOIT | SDMMC_FLAG_ACKFAIL |\ - SDMMC_FLAG_ACKTIMEOUT | SDMMC_FLAG_VSWEND | SDMMC_FLAG_CKSTOP |\ - SDMMC_FLAG_IDMATE | SDMMC_FLAG_IDMABTC)) - -#define SDMMC_STATIC_CMD_FLAGS ((uint32_t)(SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CTIMEOUT | SDMMC_FLAG_CMDREND |\ - SDMMC_FLAG_CMDSENT | SDMMC_FLAG_BUSYD0END)) - -#define SDMMC_STATIC_DATA_FLAGS ((uint32_t)(SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_TXUNDERR |\ - SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DATAEND | SDMMC_FLAG_DHOLD |\ - SDMMC_FLAG_DBCKEND | SDMMC_FLAG_DABORT | SDMMC_FLAG_IDMATE |\ - SDMMC_FLAG_IDMABTC)) -/** - * @} - */ - -/** @defgroup SDMMC_SDIO_CCCR_Registers - * @{ - */ -/*-------------------------------- CCCR0 ----------------------------------*/ -#define SDMMC_SDIO_CCCR0 0x000U /*!< SDIOS Card Common Control Register 0 */ -#define SDMMC_SDIO_CCCR0_SD_BYTE0 0x000U /*!< SDIOS Card Common Control Register 0 Byte 0 */ -#define SDMMC_SDIO_CCCR0_SD_BYTE1 0x001U /*!< SDIOS Card Common Control Register 0 Byte 1 */ -#define SDMMC_SDIO_CCCR0_SD_BYTE2 0x002U /*!< SDIOS Card Common Control Register 0 Byte 2 */ -#define SDMMC_SDIO_CCCR0_SD_BYTE3 0x003U /*!< SDIOS Card Common Control Register 0 Byte 3 */ - -/*-------------------------------- CCCR4 ----------------------------------*/ -#define SDMMC_SDIO_CCCR4 0x004U /*!< SDIOS Card Common Control Register 4 */ -#define SDMMC_SDIO_CCCR4_SD_BYTE0 0x004U /*!< SDIOS Card Common Control Register 4 Byte 0 */ -#define SDMMC_SDIO_CCCR4_SD_BYTE1 0x005U /*!< SDIOS Card Common Control Register 4 Byte 1 */ -#define SDMMC_SDIO_CCCR4_SD_BYTE2 0x006U /*!< SDIOS Card Common Control Register 4 Byte 2 */ -#define SDMMC_SDIO_CCCR4_SD_BYTE3 0x007U /*!< SDIOS Card Common Control Register 4 Byte 3 */ - -/*-------------------------------- CCCR8 ----------------------------------*/ -#define SDMMC_SDIO_CCCR8 0x008U /*!< SDIOS Card Common Control Register 8 */ -#define SDMMC_SDIO_CCCR8_SD_BYTE0 0x008U /*!< SDIOS Card Common Control Register 8 Byte 0 */ -#define SDMMC_SDIO_CCCR8_SD_BYTE1 0x009U /*!< SDIOS Card Common Control Register 8 Byte 1 */ -#define SDMMC_SDIO_CCCR8_SD_BYTE2 0x00AU /*!< SDIOS Card Common Control Register 8 Byte 2 */ -#define SDMMC_SDIO_CCCR8_SD_BYTE3 0x00BU /*!< SDIOS Card Common Control Register 8 Byte 3 */ - -/*-------------------------------- CCCR12 ---------------------------------*/ -#define SDMMC_SDIO_CCCR12 0x00CU /*!< SDIOS Card Common Control Register 12 */ -#define SDMMC_SDIO_CCCR12_SD_BYTE0 0x00CU /*!< SDIOS Card Common Control Register 12 Byte 0 */ -#define SDMMC_SDIO_CCCR12_SD_BYTE1 0x00DU /*!< SDIOS Card Common Control Register 12 Byte 1 */ -#define SDMMC_SDIO_CCCR12_SD_BYTE2 0x00EU /*!< SDIOS Card Common Control Register 12 Byte 2 */ -#define SDMMC_SDIO_CCCR12_SD_BYTE3 0x00FU /*!< SDIOS Card Common Control Register 12 Byte 3 */ - -/*-------------------------------- CCCR16 ---------------------------------*/ -#define SDMMC_SDIO_CCCR16 0x010U /*!< SDIOS Card Common Control Register 16 */ -#define SDMMC_SDIO_CCCR16_SD_BYTE0 0x010U /*!< SDIOS Card Common Control Register 16 Byte 0 */ -#define SDMMC_SDIO_CCCR16_SD_BYTE1 0x011U /*!< SDIOS Card Common Control Register 16 Byte 1 */ -#define SDMMC_SDIO_CCCR16_SD_BYTE2 0x012U /*!< SDIOS Card Common Control Register 16 Byte 2 */ -#define SDMMC_SDIO_CCCR16_SD_BYTE3 0x013U /*!< SDIOS Card Common Control Register 16 Byte 3 */ - -/*-------------------------------- CCCR20 ---------------------------------*/ -#define SDMMC_SDIO_CCCR20 0x014U /*!< SDIOS Card Common Control Register 20 */ -#define SDMMC_SDIO_CCCR20_SD_BYTE0 0x014U /*!< SDIOS Card Common Control Register 20 Byte 0 */ -#define SDMMC_SDIO_CCCR20_SD_BYTE1 0x015U /*!< SDIOS Card Common Control Register 20 Byte 1 */ -#define SDMMC_SDIO_CCCR20_SD_BYTE2 0x016U /*!< SDIOS Card Common Control Register 20 Byte 2 */ -#define SDMMC_SDIO_CCCR20_SD_BYTE3 0x017U /*!< SDIOS Card Common Control Register 20 Byte 3 */ - -/*-------------------------------- F1BR0 ----------------------------------*/ -#define SDMMC_SDIO_F1BR0 0x100U /*!< SDIOS Function 1 Basic Register 0 */ -#define SDMMC_SDIO_F1BR0_SD_BYTE0 0x100U /*!< SDIOS Function 1 Basic Register 0 Byte 0 */ -#define SDMMC_SDIO_F1BR0_SD_BYTE1 0x101U /*!< SDIOS Function 1 Basic Register 0 Byte 1 */ -#define SDMMC_SDIO_F1BR0_SD_BYTE2 0x102U /*!< SDIOS Function 1 Basic Register 0 Byte 2 */ -#define SDMMC_SDIO_F1BR0_SD_BYTE3 0x103U /*!< SDIOS Function 1 Basic Register 0 Byte 3 */ - -/*-------------------------------- F1BR8 ----------------------------------*/ -#define SDMMC_SDIO_F1BR8 0x108U /*!< SDIOS Function 1 Basic Register 8 */ -#define SDMMC_SDIO_F1BR8_SD_BYTE0 0x108U /*!< SDIOS Function 1 Basic Register 8 Byte 0 */ -#define SDMMC_SDIO_F1BR8_SD_BYTE1 0x109U /*!< SDIOS Function 1 Basic Register 8 Byte 1 */ -#define SDMMC_SDIO_F1BR8_SD_BYTE2 0x10AU /*!< SDIOS Function 1 Basic Register 8 Byte 2 */ -#define SDMMC_SDIO_F1BR8_SD_BYTE3 0x10BU /*!< SDIOS Function 1 Basic Register 8 Byte 3 */ - -/*-------------------------------- F1BR12 ---------------------------------*/ -#define SDMMC_SDIO_F1BR12 0x10CU /*!< SDIOS Function 1 Basic Register 12 */ -#define SDMMC_SDIO_F1BR12_SD_BYTE0 0x10CU /*!< SDIOS Function 1 Basic Register 12 Byte 0 */ -#define SDMMC_SDIO_F1BR12_SD_BYTE1 0x10DU /*!< SDIOS Function 1 Basic Register 12 Byte 1 */ -#define SDMMC_SDIO_F1BR12_SD_BYTE2 0x10EU /*!< SDIOS Function 1 Basic Register 12 Byte 2 */ -#define SDMMC_SDIO_F1BR12_SD_BYTE3 0x10FU /*!< SDIOS Function 1 Basic Register 12 Byte 3 */ - -/*-------------------------------- F1BR16 ---------------------------------*/ -#define SDMMC_SDIO_F1BR16 0x110U /*!< SDIOS Function 1 Basic Register 16 */ -#define SDMMC_SDIO_F1BR16_SD_BYTE0 0x110U /*!< SDIOS Function 1 Basic Register 16 Byte 0 */ -#define SDMMC_SDIO_F1BR16_SD_BYTE1 0x111U /*!< SDIOS Function 1 Basic Register 16 Byte 1 */ -#define SDMMC_SDIO_F1BR16_SD_BYTE2 0x112U /*!< SDIOS Function 1 Basic Register 16 Byte 2 */ -#define SDMMC_SDIO_F1BR16_SD_BYTE3 0x113U /*!< SDIOS Function 1 Basic Register 16 Byte 3 */ -/** - * @} - */ - -/** - * @} - */ - -/* Exported macro ------------------------------------------------------------*/ -/** @defgroup SDMMC_LL_Exported_macros SDMMC_LL Exported Macros - * @{ - */ - -/** @defgroup SDMMC_LL_Register Bits And Addresses Definitions - * @brief SDMMC_LL registers bit address in the alias region - * @{ - */ -/* ---------------------- SDMMC registers bit mask --------------------------- */ -/* --- CLKCR Register ---*/ -/* CLKCR register clear mask */ -#define CLKCR_CLEAR_MASK ((uint32_t)(SDMMC_CLKCR_CLKDIV | SDMMC_CLKCR_PWRSAV |\ - SDMMC_CLKCR_WIDBUS |\ - SDMMC_CLKCR_NEGEDGE | SDMMC_CLKCR_HWFC_EN |\ - SDMMC_CLKCR_DDR | SDMMC_CLKCR_BUSSPEED |\ - SDMMC_CLKCR_SELCLKRX)) - -/* --- DCTRL Register ---*/ -/* SDMMC DCTRL Clear Mask */ -#define DCTRL_CLEAR_MASK ((uint32_t)(SDMMC_DCTRL_DTEN | SDMMC_DCTRL_DTDIR |\ - SDMMC_DCTRL_DTMODE | SDMMC_DCTRL_DBLOCKSIZE)) - -/* --- CMD Register ---*/ -/* CMD Register clear mask */ -#define CMD_CLEAR_MASK ((uint32_t)(SDMMC_CMD_CMDINDEX | SDMMC_CMD_WAITRESP |\ - SDMMC_CMD_WAITINT | SDMMC_CMD_WAITPEND |\ - SDMMC_CMD_CPSMEN | SDMMC_CMD_CMDSUSPEND)) - -/* SDMMC Initialization Frequency (400KHz max) for Peripheral CLK 200MHz*/ -#define SDMMC_INIT_CLK_DIV ((uint8_t)0xFA) - -/* SDMMC Default Speed Frequency (25Mhz max) for Peripheral CLK 200MHz*/ -#define SDMMC_NSPEED_CLK_DIV ((uint8_t)0x4) - -/* SDMMC High Speed Frequency (50Mhz max) for Peripheral CLK 200MHz*/ -#define SDMMC_HSPEED_CLK_DIV ((uint8_t)0x2) -/** - * @} - */ - -/** @defgroup SDMMC_LL_Interrupt_Clock Interrupt And Clock Configuration - * @brief macros to handle interrupts and specific clock configurations - * @{ - */ - -/** - * @brief Enable the SDMMC device interrupt. - * @param __INSTANCE__ Pointer to SDMMC register base - * @param __INTERRUPT__ specifies the SDMMC interrupt sources to be enabled. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __SDMMC_ENABLE_IT(__INSTANCE__, __INTERRUPT__) ((__INSTANCE__)->MASK |= (__INTERRUPT__)) - -/** - * @brief Disable the SDMMC device interrupt. - * @param __INSTANCE__ Pointer to SDMMC register base - * @param __INTERRUPT__ specifies the SDMMC interrupt sources to be disabled. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __SDMMC_DISABLE_IT(__INSTANCE__, __INTERRUPT__) ((__INSTANCE__)->MASK &= ~(__INTERRUPT__)) - -/** - * @brief Checks whether the specified SDMMC flag is set or not. - * @param __INSTANCE__ Pointer to SDMMC register base - * @param __FLAG__ specifies the flag to check. - * This parameter can be one of the following values: - * @arg SDMMC_FLAG_CCRCFAIL: Command response received (CRC check failed) - * @arg SDMMC_FLAG_DCRCFAIL: Data block sent/received (CRC check failed) - * @arg SDMMC_FLAG_CTIMEOUT: Command response timeout - * @arg SDMMC_FLAG_DTIMEOUT: Data timeout - * @arg SDMMC_FLAG_TXUNDERR: Transmit FIFO underrun error - * @arg SDMMC_FLAG_RXOVERR: Received FIFO overrun error - * @arg SDMMC_FLAG_CMDREND: Command response received (CRC check passed) - * @arg SDMMC_FLAG_CMDSENT: Command sent (no response required) - * @arg SDMMC_FLAG_DATAEND: Data end (data counter, DATACOUNT, is zero) - * @arg SDMMC_FLAG_DHOLD: Data transfer Hold - * @arg SDMMC_FLAG_DBCKEND: Data block sent/received (CRC check passed) - * @arg SDMMC_FLAG_DABORT: Data transfer aborted by CMD12 - * @arg SDMMC_FLAG_DPSMACT: Data path state machine active - * @arg SDMMC_FLAG_CPSMACT: Command path state machine active - * @arg SDMMC_FLAG_TXFIFOHE: Transmit FIFO Half Empty - * @arg SDMMC_FLAG_RXFIFOHF: Receive FIFO Half Full - * @arg SDMMC_FLAG_TXFIFOF: Transmit FIFO full - * @arg SDMMC_FLAG_RXFIFOF: Receive FIFO full - * @arg SDMMC_FLAG_TXFIFOE: Transmit FIFO empty - * @arg SDMMC_FLAG_RXFIFOE: Receive FIFO empty - * @arg SDMMC_FLAG_BUSYD0: Inverted value of SDMMC_D0 line (Busy) - * @arg SDMMC_FLAG_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected - * @arg SDMMC_FLAG_SDIOIT: SDIO interrupt received - * @arg SDMMC_FLAG_ACKFAIL: Boot Acknowledgment received - * @arg SDMMC_FLAG_ACKTIMEOUT: Boot Acknowledgment timeout - * @arg SDMMC_FLAG_VSWEND: Voltage switch critical timing section completion - * @arg SDMMC_FLAG_CKSTOP: SDMMC_CK stopped in Voltage switch procedure - * @arg SDMMC_FLAG_IDMATE: IDMA transfer error - * @arg SDMMC_FLAG_IDMABTC: IDMA buffer transfer complete - * @retval The new state of SDMMC_FLAG (SET or RESET). - */ -#define __SDMMC_GET_FLAG(__INSTANCE__, __FLAG__) (((__INSTANCE__)->STA &(__FLAG__)) != 0U) - - -/** - * @brief Clears the SDMMC pending flags. - * @param __INSTANCE__ Pointer to SDMMC register base - * @param __FLAG__ specifies the flag to clear. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_FLAG_CCRCFAIL: Command response received (CRC check failed) - * @arg SDMMC_FLAG_DCRCFAIL: Data block sent/received (CRC check failed) - * @arg SDMMC_FLAG_CTIMEOUT: Command response timeout - * @arg SDMMC_FLAG_DTIMEOUT: Data timeout - * @arg SDMMC_FLAG_TXUNDERR: Transmit FIFO underrun error - * @arg SDMMC_FLAG_RXOVERR: Received FIFO overrun error - * @arg SDMMC_FLAG_CMDREND: Command response received (CRC check passed) - * @arg SDMMC_FLAG_CMDSENT: Command sent (no response required) - * @arg SDMMC_FLAG_DATAEND: Data end (data counter, DATACOUNT, is zero) - * @arg SDMMC_FLAG_DHOLD: Data transfer Hold - * @arg SDMMC_FLAG_DBCKEND: Data block sent/received (CRC check passed) - * @arg SDMMC_FLAG_DABORT: Data transfer aborted by CMD12 - * @arg SDMMC_FLAG_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected - * @arg SDMMC_FLAG_SDIOIT: SDIO interrupt received - * @arg SDMMC_FLAG_ACKFAIL: Boot Acknowledgment received - * @arg SDMMC_FLAG_ACKTIMEOUT: Boot Acknowledgment timeout - * @arg SDMMC_FLAG_VSWEND: Voltage switch critical timing section completion - * @arg SDMMC_FLAG_CKSTOP: SDMMC_CK stopped in Voltage switch procedure - * @arg SDMMC_FLAG_IDMATE: IDMA transfer error - * @arg SDMMC_FLAG_IDMABTC: IDMA buffer transfer complete - * @retval None - */ -#define __SDMMC_CLEAR_FLAG(__INSTANCE__, __FLAG__) ((__INSTANCE__)->ICR = (__FLAG__)) - -/** - * @brief Checks whether the specified SDMMC interrupt has occurred or not. - * @param __INSTANCE__ Pointer to SDMMC register base - * @param __INTERRUPT__ specifies the SDMMC interrupt source to check. - * This parameter can be one of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval The new state of SDMMC_IT (SET or RESET). - */ -#define __SDMMC_GET_IT(__INSTANCE__, __INTERRUPT__) (((__INSTANCE__)->STA &(__INTERRUPT__)) == (__INTERRUPT__)) - -/** - * @brief Checks the source of specified interrupt. - * @param __INSTANCE__ Pointer to SDMMC register base - * @param __INTERRUPT__ specifies the SDMMC interrupt source to check. - * This parameter can be one of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_TXFIFOHE: Transmit FIFO Half Empty interrupt - * @arg SDMMC_IT_RXFIFOHF: Receive FIFO Half Full interrupt - * @arg SDMMC_IT_RXFIFOF: Receive FIFO full interrupt - * @arg SDMMC_IT_TXFIFOE: Transmit FIFO empty interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval The new state of SDMMC_IT (SET or RESET). - */ -#define __SDMMC_GET_IT_SOURCE(__INSTANCE__, __INTERRUPT__) (((__HANDLE__)->Instance->STA & (__INTERRUPT__))) - -/** - * @brief Clears the SDMMC's interrupt pending bits. - * @param __INSTANCE__ Pointer to SDMMC register base - * @param __INTERRUPT__ specifies the interrupt pending bit to clear. - * This parameter can be one or a combination of the following values: - * @arg SDMMC_IT_CCRCFAIL: Command response received (CRC check failed) interrupt - * @arg SDMMC_IT_DCRCFAIL: Data block sent/received (CRC check failed) interrupt - * @arg SDMMC_IT_CTIMEOUT: Command response timeout interrupt - * @arg SDMMC_IT_DTIMEOUT: Data timeout interrupt - * @arg SDMMC_IT_TXUNDERR: Transmit FIFO underrun error interrupt - * @arg SDMMC_IT_RXOVERR: Received FIFO overrun error interrupt - * @arg SDMMC_IT_CMDREND: Command response received (CRC check passed) interrupt - * @arg SDMMC_IT_CMDSENT: Command sent (no response required) interrupt - * @arg SDMMC_IT_DATAEND: Data end (data counter, DATACOUNT, is zero) interrupt - * @arg SDMMC_IT_DHOLD: Data transfer Hold interrupt - * @arg SDMMC_IT_DBCKEND: Data block sent/received (CRC check passed) interrupt - * @arg SDMMC_IT_DABORT: Data transfer aborted by CMD12 interrupt - * @arg SDMMC_IT_BUSYD0END: End of SDMMC_D0 Busy following a CMD response detected interrupt - * @arg SDMMC_IT_SDIOIT: SDIO interrupt received interrupt - * @arg SDMMC_IT_ACKFAIL: Boot Acknowledgment received interrupt - * @arg SDMMC_IT_ACKTIMEOUT: Boot Acknowledgment timeout interrupt - * @arg SDMMC_IT_VSWEND: Voltage switch critical timing section completion interrupt - * @arg SDMMC_IT_CKSTOP: SDMMC_CK stopped in Voltage switch procedure interrupt - * @arg SDMMC_IT_IDMABTC: IDMA buffer transfer complete interrupt - * @retval None - */ -#define __SDMMC_CLEAR_IT(__INSTANCE__, __INTERRUPT__) ((__INSTANCE__)->ICR = (__INTERRUPT__)) - -/** - * @brief Enable Start the SD I/O Read Wait operation. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_START_READWAIT_ENABLE(__INSTANCE__) ((__INSTANCE__)->DCTRL |= SDMMC_DCTRL_RWSTART) - -/** - * @brief Disable Start the SD I/O Read Wait operations. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_START_READWAIT_DISABLE(__INSTANCE__) ((__INSTANCE__)->DCTRL &= ~SDMMC_DCTRL_RWSTART) - -/** - * @brief Enable Start the SD I/O Read Wait operation. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_STOP_READWAIT_ENABLE(__INSTANCE__) ((__INSTANCE__)->DCTRL |= SDMMC_DCTRL_RWSTOP) - -/** - * @brief Disable Stop the SD I/O Read Wait operations. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_STOP_READWAIT_DISABLE(__INSTANCE__) ((__INSTANCE__)->DCTRL &= ~SDMMC_DCTRL_RWSTOP) - -/** - * @brief Enable the SD I/O Mode Operation. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_OPERATION_ENABLE(__INSTANCE__) ((__INSTANCE__)->DCTRL |= SDMMC_DCTRL_SDIOEN) - -/** - * @brief Disable the SD I/O Mode Operation. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_OPERATION_DISABLE(__INSTANCE__) ((__INSTANCE__)->DCTRL &= ~SDMMC_DCTRL_SDIOEN) - -/** - * @brief Enable the SD I/O Suspend command sending. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_SUSPEND_CMD_ENABLE(__INSTANCE__) ((__INSTANCE__)->CMD |= SDMMC_CMD_CMDSUSPEND) - -/** - * @brief Disable the SD I/O Suspend command sending. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_SUSPEND_CMD_DISABLE(__INSTANCE__) ((__INSTANCE__)->CMD &= ~SDMMC_CMD_CMDSUSPEND) - -/** - * @brief Enable the CMDTRANS mode. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_CMDTRANS_ENABLE(__INSTANCE__) ((__INSTANCE__)->CMD |= SDMMC_CMD_CMDTRANS) - -/** - * @brief Disable the CMDTRANS mode. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_CMDTRANS_DISABLE(__INSTANCE__) ((__INSTANCE__)->CMD &= ~SDMMC_CMD_CMDTRANS) - -/** - * @brief Enable the CMDSTOP mode. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_CMDSTOP_ENABLE(__INSTANCE__) ((__INSTANCE__)->CMD |= SDMMC_CMD_CMDSTOP) - -/** - * @brief Disable the CMDSTOP mode. - * @param __INSTANCE__ Pointer to SDMMC register base - * @retval None - */ -#define __SDMMC_CMDSTOP_DISABLE(__INSTANCE__) ((__INSTANCE__)->CMD &= ~SDMMC_CMD_CMDSTOP) - -/** - * @} - */ - -/** - * @} - */ - -/* Exported functions --------------------------------------------------------*/ -/** @addtogroup SDMMC_LL_Exported_Functions - * @{ - */ - -/* Initialization/de-initialization functions **********************************/ -/** @addtogroup HAL_SDMMC_LL_Group1 - * @{ - */ -HAL_StatusTypeDef SDMMC_Init(SDMMC_TypeDef *SDMMCx, SDMMC_InitTypeDef Init); -/** - * @} - */ - -/* I/O operation functions *****************************************************/ -/** @addtogroup HAL_SDMMC_LL_Group2 - * @{ - */ -uint32_t SDMMC_ReadFIFO(const SDMMC_TypeDef *SDMMCx); -HAL_StatusTypeDef SDMMC_WriteFIFO(SDMMC_TypeDef *SDMMCx, uint32_t *pWriteData); -/** - * @} - */ - -/* Peripheral Control functions ************************************************/ -/** @addtogroup HAL_SDMMC_LL_Group3 - * @{ - */ -HAL_StatusTypeDef SDMMC_PowerState_ON(SDMMC_TypeDef *SDMMCx); -HAL_StatusTypeDef SDMMC_PowerState_Cycle(SDMMC_TypeDef *SDMMCx); -HAL_StatusTypeDef SDMMC_PowerState_OFF(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_GetPowerState(const SDMMC_TypeDef *SDMMCx); - -/* Command path state machine (CPSM) management functions */ -HAL_StatusTypeDef SDMMC_SendCommand(SDMMC_TypeDef *SDMMCx, const SDMMC_CmdInitTypeDef *Command); -uint8_t SDMMC_GetCommandResponse(const SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_GetResponse(const SDMMC_TypeDef *SDMMCx, uint32_t Response); - -/* Data path state machine (DPSM) management functions */ -HAL_StatusTypeDef SDMMC_ConfigData(SDMMC_TypeDef *SDMMCx, const SDMMC_DataInitTypeDef *Data); -uint32_t SDMMC_GetDataCounter(const SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_GetFIFOCount(const SDMMC_TypeDef *SDMMCx); - -/* SDMMC Cards mode management functions */ -HAL_StatusTypeDef SDMMC_SetSDMMCReadWaitMode(SDMMC_TypeDef *SDMMCx, uint32_t SDMMC_ReadWaitMode); -/** - * @} - */ - -/* SDMMC Commands management functions ******************************************/ -/** @addtogroup HAL_SDMMC_LL_Group4 - * @{ - */ -uint32_t SDMMC_CmdBlockLength(SDMMC_TypeDef *SDMMCx, uint32_t BlockSize); -uint32_t SDMMC_CmdReadSingleBlock(SDMMC_TypeDef *SDMMCx, uint32_t ReadAdd); -uint32_t SDMMC_CmdReadMultiBlock(SDMMC_TypeDef *SDMMCx, uint32_t ReadAdd); -uint32_t SDMMC_CmdWriteSingleBlock(SDMMC_TypeDef *SDMMCx, uint32_t WriteAdd); -uint32_t SDMMC_CmdWriteMultiBlock(SDMMC_TypeDef *SDMMCx, uint32_t WriteAdd); -uint32_t SDMMC_CmdEraseStartAdd(SDMMC_TypeDef *SDMMCx, uint32_t StartAdd); -uint32_t SDMMC_CmdSDEraseStartAdd(SDMMC_TypeDef *SDMMCx, uint32_t StartAdd); -uint32_t SDMMC_CmdEraseEndAdd(SDMMC_TypeDef *SDMMCx, uint32_t EndAdd); -uint32_t SDMMC_CmdSDEraseEndAdd(SDMMC_TypeDef *SDMMCx, uint32_t EndAdd); -uint32_t SDMMC_CmdErase(SDMMC_TypeDef *SDMMCx, uint32_t EraseType); -uint32_t SDMMC_CmdStopTransfer(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_CmdSelDesel(SDMMC_TypeDef *SDMMCx, uint32_t Addr); -uint32_t SDMMC_CmdGoIdleState(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_CmdOperCond(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_CmdAppCommand(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdAppOperCommand(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdBusWidth(SDMMC_TypeDef *SDMMCx, uint32_t BusWidth); -uint32_t SDMMC_CmdSendSCR(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_CmdSendCID(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_CmdSendCSD(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdSetRelAdd(SDMMC_TypeDef *SDMMCx, uint16_t *pRCA); -uint32_t SDMMC_CmdSetRelAddMmc(SDMMC_TypeDef *SDMMCx, uint16_t RCA); -uint32_t SDMMC_CmdSleepMmc(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdSendStatus(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdStatusRegister(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_CmdVoltageSwitch(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_CmdOpCondition(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdSwitch(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdSendEXTCSD(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdBlockCount(SDMMC_TypeDef *SDMMCx, uint32_t BlockCount); -uint32_t SDMMC_SDIO_CmdReadWriteDirect(SDMMC_TypeDef *SDMMCx, uint32_t Argument, uint8_t *pResponse); -uint32_t SDMMC_SDIO_CmdReadWriteExtended(SDMMC_TypeDef *SDMMCx, uint32_t Argument); -uint32_t SDMMC_CmdSendOperationcondition(SDMMC_TypeDef *SDMMCx, uint32_t Argument, uint32_t *pResp); -/** - * @} - */ - -/* SDMMC Responses management functions *****************************************/ -/** @addtogroup HAL_SDMMC_LL_Group5 - * @{ - */ -uint32_t SDMMC_GetCmdResp1(SDMMC_TypeDef *SDMMCx, uint8_t SD_CMD, uint32_t Timeout); -uint32_t SDMMC_GetCmdResp2(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_GetCmdResp3(SDMMC_TypeDef *SDMMCx); -uint32_t SDMMC_GetCmdResp4(SDMMC_TypeDef *SDMMCx, uint32_t *pResp); -uint32_t SDMMC_GetCmdResp5(SDMMC_TypeDef *SDMMCx, uint8_t SDIO_CMD, uint8_t *pData); -uint32_t SDMMC_GetCmdResp6(SDMMC_TypeDef *SDMMCx, uint8_t SD_CMD, uint16_t *pRCA); -uint32_t SDMMC_GetCmdResp7(SDMMC_TypeDef *SDMMCx); -/** - * @} - */ - - -/** - * @} - */ - -/** - * @} - */ - -/** - * @} - */ - -/** - * @} - */ -#endif /* SDMMC1 || SDMMC2 */ -/** - * @} - */ -#ifdef __cplusplus -} -#endif - -#endif /* STM32H7xx_LL_SDMMC_H */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c b/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c deleted file mode 100644 index b67bdef..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c +++ /dev/null @@ -1,5964 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_mmc.c - * @author MCD Application Team - * @brief MMC card HAL module driver. - * This file provides firmware functions to manage the following - * functionalities of the Secure Digital (MMC) peripheral: - * + Initialization and de-initialization functions - * + IO operation functions - * + Peripheral Control functions - * + MMC card Control functions - * - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - @verbatim - ============================================================================== - ##### How to use this driver ##### - ============================================================================== - [..] - This driver implements a high level communication layer for read and write from/to - this memory. The needed STM32 hardware resources (SDMMC and GPIO) are performed by - the user in HAL_MMC_MspInit() function (MSP layer). - Basically, the MSP layer configuration should be the same as we provide in the - examples. - You can easily tailor this configuration according to hardware resources. - - [..] - This driver is a generic layered driver for SDMMC memories which uses the HAL - SDMMC driver functions to interface with MMC and eMMC cards devices. - It is used as follows: - - (#)Initialize the SDMMC low level resources by implement the HAL_MMC_MspInit() API: - (##) Enable the SDMMC interface clock using __HAL_RCC_SDMMC_CLK_ENABLE(); - (##) SDMMC pins configuration for MMC card - (+++) Enable the clock for the SDMMC GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE(); - (+++) Configure these SDMMC pins as alternate function pull-up using HAL_GPIO_Init() - and according to your pin assignment; - (##) NVIC configuration if you need to use interrupt process (HAL_MMC_ReadBlocks_IT() - and HAL_MMC_WriteBlocks_IT() APIs). - (+++) Configure the SDMMC interrupt priorities using function HAL_NVIC_SetPriority(); - (+++) Enable the NVIC SDMMC IRQs using function HAL_NVIC_EnableIRQ() - (+++) SDMMC interrupts are managed using the macros __HAL_MMC_ENABLE_IT() - and __HAL_MMC_DISABLE_IT() inside the communication process. - (+++) SDMMC interrupts pending bits are managed using the macros __HAL_MMC_GET_IT() - and __HAL_MMC_CLEAR_IT() - (##) No general propose DMA Configuration is needed, an Internal DMA for SDMMC Peripheral are used. - - (#) At this stage, you can perform MMC read/write/erase operations after MMC card initialization - - *** MMC Card Initialization and configuration *** - ================================================ - [..] - To initialize the MMC Card, use the HAL_MMC_Init() function. It Initializes - SDMMC Peripheral (STM32 side) and the MMC Card, and put it into StandBy State (Ready for data transfer). - This function provide the following operations: - - (#) Initialize the SDMMC peripheral interface with default configuration. - The initialization process is done at 400KHz. You can change or adapt - this frequency by adjusting the "ClockDiv" field. - The MMC Card frequency (SDMMC_CK) is computed as follows: - - SDMMC_CK = SDMMCCLK / (2 * ClockDiv) - - In initialization mode and according to the MMC Card standard, - make sure that the SDMMC_CK frequency doesn't exceed 400KHz. - - This phase of initialization is done through SDMMC_Init() and - SDMMC_PowerState_ON() SDMMC low level APIs. - - (#) Initialize the MMC card. The API used is HAL_MMC_InitCard(). - This phase allows the card initialization and identification - and check the MMC Card type (Standard Capacity or High Capacity) - The initialization flow is compatible with MMC standard. - - This API (HAL_MMC_InitCard()) could be used also to reinitialize the card in case - of plug-off plug-in. - - (#) Configure the MMC Card Data transfer frequency. By Default, the card transfer - frequency by adjusting the "ClockDiv" field. - In transfer mode and according to the MMC Card standard, make sure that the - SDMMC_CK frequency doesn't exceed 25MHz and 100MHz in High-speed mode switch. - - (#) Select the corresponding MMC Card according to the address read with the step 2. - - (#) Configure the MMC Card in wide bus mode: 4-bits data. - (#) Select the MMC Card partition using HAL_MMC_SwitchPartition() - - *** MMC Card Read operation *** - ============================== - [..] - (+) You can read from MMC card in polling mode by using function HAL_MMC_ReadBlocks(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetCardState() function for MMC card state. - - (+) You can read from MMC card in DMA mode by using function HAL_MMC_ReadBlocks_DMA(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetCardState() function for MMC card state. - You could also check the DMA transfer process through the MMC Rx interrupt event. - - (+) You can read from MMC card in Interrupt mode by using function HAL_MMC_ReadBlocks_IT(). - This function allows the read of 512 bytes blocks. - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetCardState() function for MMC card state. - You could also check the IT transfer process through the MMC Rx interrupt event. - - *** MMC Card Write operation *** - =============================== - [..] - (+) You can write to MMC card in polling mode by using function HAL_MMC_WriteBlocks(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetCardState() function for MMC card state. - - (+) You can write to MMC card in DMA mode by using function HAL_MMC_WriteBlocks_DMA(). - This function support only 512-bytes block length (the block size should be - chosen as 512 byte). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetCardState() function for MMC card state. - You could also check the DMA transfer process through the MMC Tx interrupt event. - - (+) You can write to MMC card in Interrupt mode by using function HAL_MMC_WriteBlocks_IT(). - This function allows the read of 512 bytes blocks. - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetCardState() function for MMC card state. - You could also check the IT transfer process through the MMC Tx interrupt event. - - *** MMC card information *** - =========================== - [..] - (+) To get MMC card information, you can use the function HAL_MMC_GetCardInfo(). - It returns useful information about the MMC card such as block size, card type, - block number ... - - *** MMC card CSD register *** - ============================ - [..] - (+) The HAL_MMC_GetCardCSD() API allows to get the parameters of the CSD register. - Some of the CSD parameters are useful for card initialization and identification. - - *** MMC card CID register *** - ============================ - [..] - (+) The HAL_MMC_GetCardCID() API allows to get the parameters of the CID register. - Some of the CID parameters are useful for card initialization and identification. - - *** MMC Card Reply Protected Memory Block (RPMB) Key Programming operation *** - ============================== - [..] - (+) You can program the authentication key of RPMB area in polling mode by using function - HAL_MMC_RPMB_ProgramAuthenticationKey(). - This function is only used once during the life of an MMC card. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetRPMBError() function for operation state. - (+) You can program the authentication key of RPMB area in Interrupt mode by using function - HAL_MMC_RPMB_ProgramAuthenticationKey_IT(). - This function is only used once during the life of an MMC card. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetRPMBError() function for operation state. - - *** MMC Card Reply Protected Memory Block (RPMB) write counter operation *** - ============================== - [..] - (+) You can get the write counter value of RPMB area in polling mode by using function - HAL_MMC_RPMB_GetWriteCounter(). - (+) You can get the write counter value of RPMB area in Interrupt mode by using function - HAL_MMC_RPMB_GetWriteCounter_IT(). - - *** MMC Card Reply Protected Memory Block (RPMB) write operation *** - ============================== - [..] - (+) You can write to the RPMB area of MMC card in polling mode by using function - HAL_MMC_WriteBlocks(). - This function supports the one, two, or thirty two blocks write operation - (with 512-bytes block length). - You can choose the number of blocks at the multiple block read operation by adjusting - the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetRPMBError() function for operation state. - (+) You can write to the RPMB area of MMC card in Interrupt mode by using function - HAL_MMC_WriteBlocks_IT(). - This function supports the one, two, or thirty two blocks write operation - (with 512-bytes block length). - You can choose the number of blocks at the multiple block read operation by adjusting - the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetRPMBError() function for operation state. - - *** MMC Card Reply Protected Memory Block (RPMB) read operation *** - ============================== - [..] - (+) You can read from the RPMB area of MMC card in polling mode by using function - HAL_MMC_RPMB_ReadBlocks(). - The block size should be chosen as multiple of 512 bytes. - You can choose the number of blocks by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetRPMBError() function for MMC card state. - (+) You can read from the RPMB area of MMC card in Interrupt mode by using function - HAL_MMC_RPMB_ReadBlocks_IT(). - The block size should be chosen as multiple of 512 bytes. - You can choose the number of blocks by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_MMC_GetRPMBError() function for MMC card state. - - *** MMC HAL driver macros list *** - ================================== - [..] - Below the list of most used macros in MMC HAL driver. - - (+) __HAL_MMC_ENABLE_IT: Enable the MMC device interrupt - (+) __HAL_MMC_DISABLE_IT: Disable the MMC device interrupt - (+) __HAL_MMC_GET_FLAG:Check whether the specified MMC flag is set or not - (+) __HAL_MMC_CLEAR_FLAG: Clear the MMC's pending flags - - [..] - (@) You can refer to the MMC HAL driver header file for more useful macros - - *** Callback registration *** - ============================================= - [..] - The compilation define USE_HAL_MMC_REGISTER_CALLBACKS when set to 1 - allows the user to configure dynamically the driver callbacks. - - Use Functions HAL_MMC_RegisterCallback() to register a user callback, - it allows to register following callbacks: - (+) TxCpltCallback : callback when a transmission transfer is completed. - (+) RxCpltCallback : callback when a reception transfer is completed. - (+) ErrorCallback : callback when error occurs. - (+) AbortCpltCallback : callback when abort is completed. - (+) Read_DMADblBuf0CpltCallback : callback when the DMA reception of first buffer is completed. - (+) Read_DMADblBuf1CpltCallback : callback when the DMA reception of second buffer is completed. - (+) Write_DMADblBuf0CpltCallback : callback when the DMA transmission of first buffer is completed. - (+) Write_DMADblBuf1CpltCallback : callback when the DMA transmission of second buffer is completed. - (+) MspInitCallback : MMC MspInit. - (+) MspDeInitCallback : MMC MspDeInit. - This function takes as parameters the HAL peripheral handle, the Callback ID - and a pointer to the user callback function. - - Use function HAL_MMC_UnRegisterCallback() to reset a callback to the default - weak (overridden) function. It allows to reset following callbacks: - (+) TxCpltCallback : callback when a transmission transfer is completed. - (+) RxCpltCallback : callback when a reception transfer is completed. - (+) ErrorCallback : callback when error occurs. - (+) AbortCpltCallback : callback when abort is completed. - (+) Read_DMADblBuf0CpltCallback : callback when the DMA reception of first buffer is completed. - (+) Read_DMADblBuf1CpltCallback : callback when the DMA reception of second buffer is completed. - (+) Write_DMADblBuf0CpltCallback : callback when the DMA transmission of first buffer is completed. - (+) Write_DMADblBuf1CpltCallback : callback when the DMA transmission of second buffer is completed. - (+) MspInitCallback : MMC MspInit. - (+) MspDeInitCallback : MMC MspDeInit. - This function) takes as parameters the HAL peripheral handle and the Callback ID. - - By default, after the HAL_MMC_Init and if the state is HAL_MMC_STATE_RESET - all callbacks are reset to the corresponding legacy weak (overridden) functions. - Exception done for MspInit and MspDeInit callbacks that are respectively - reset to the legacy weak (overridden) functions in the HAL_MMC_Init - and HAL_MMC_DeInit only when these callbacks are null (not registered beforehand). - If not, MspInit or MspDeInit are not null, the HAL_MMC_Init and HAL_MMC_DeInit - keep and use the user MspInit/MspDeInit callbacks (registered beforehand) - - Callbacks can be registered/unregistered in READY state only. - Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered - in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used - during the Init/DeInit. - In that case first register the MspInit/MspDeInit user callbacks - using HAL_MMC_RegisterCallback before calling HAL_MMC_DeInit - or HAL_MMC_Init function. - - When The compilation define USE_HAL_MMC_REGISTER_CALLBACKS is set to 0 or - not defined, the callback registering feature is not available - and weak (overridden) callbacks are used. - - @endverbatim - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ - -/** @defgroup MMC MMC - * @brief MMC HAL module driver - * @{ - */ - -#if defined (SDMMC1) || defined (SDMMC2) -#ifdef HAL_MMC_MODULE_ENABLED - -/* Private typedef -----------------------------------------------------------*/ -/* Private define ------------------------------------------------------------*/ -/** @addtogroup MMC_Private_Defines - * @{ - */ -#if defined (VDD_VALUE) && (VDD_VALUE <= 1950U) -#define MMC_VOLTAGE_RANGE EMMC_LOW_VOLTAGE_RANGE - -#define MMC_EXT_CSD_PWR_CL_26_INDEX 201 -#define MMC_EXT_CSD_PWR_CL_52_INDEX 200 -#define MMC_EXT_CSD_PWR_CL_DDR_52_INDEX 238 - -#define MMC_EXT_CSD_PWR_CL_26_POS 8 -#define MMC_EXT_CSD_PWR_CL_52_POS 0 -#define MMC_EXT_CSD_PWR_CL_DDR_52_POS 16 -#else -#define MMC_VOLTAGE_RANGE EMMC_HIGH_VOLTAGE_RANGE - -#define MMC_EXT_CSD_PWR_CL_26_INDEX 203 -#define MMC_EXT_CSD_PWR_CL_52_INDEX 202 -#define MMC_EXT_CSD_PWR_CL_DDR_52_INDEX 239 - -#define MMC_EXT_CSD_PWR_CL_26_POS 24 -#define MMC_EXT_CSD_PWR_CL_52_POS 16 -#define MMC_EXT_CSD_PWR_CL_DDR_52_POS 24 -#endif /* (VDD_VALUE) && (VDD_VALUE <= 1950U)*/ - -#define MMC_EXT_CSD_SLEEP_NOTIFICATION_TIME_INDEX 216 -#define MMC_EXT_CSD_SLEEP_NOTIFICATION_TIME_POS 0 -#define MMC_EXT_CSD_S_A_TIMEOUT_INDEX 217 -#define MMC_EXT_CSD_S_A_TIMEOUT_POS 8 - -/* Frequencies used in the driver for clock divider calculation */ -#define MMC_INIT_FREQ 400000U /* Initialization phase : 400 kHz max */ -#define MMC_HIGH_SPEED_FREQ 52000000U /* High speed phase : 52 MHz max */ - -/* The Data elements' postitions in the frame Frame for RPMB area */ -#define MMC_RPMB_KEYMAC_POSITION 196U -#define MMC_RPMB_DATA_POSITION 228U -#define MMC_RPMB_NONCE_POSITION 484U -#define MMC_RPMB_WRITE_COUNTER_POSITION 500U -/** - * @} - */ - -/* Private macro -------------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -/* Private function prototypes -----------------------------------------------*/ -/* Private functions ---------------------------------------------------------*/ -/** @defgroup MMC_Private_Functions MMC Private Functions - * @{ - */ -static uint32_t MMC_InitCard(MMC_HandleTypeDef *hmmc); -static uint32_t MMC_PowerON(MMC_HandleTypeDef *hmmc); -static uint32_t MMC_SendStatus(MMC_HandleTypeDef *hmmc, uint32_t *pCardStatus); -static void MMC_PowerOFF(MMC_HandleTypeDef *hmmc); -static void MMC_Write_IT(MMC_HandleTypeDef *hmmc); -static void MMC_Read_IT(MMC_HandleTypeDef *hmmc); -static uint32_t MMC_HighSpeed(MMC_HandleTypeDef *hmmc, FunctionalState state); -static uint32_t MMC_DDR_Mode(MMC_HandleTypeDef *hmmc, FunctionalState state); -static HAL_StatusTypeDef MMC_ReadExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pFieldData, uint16_t FieldIndex, - uint32_t Timeout); -static uint32_t MMC_PwrClassUpdate(MMC_HandleTypeDef *hmmc, uint32_t Wide, uint32_t Speed); - -/** - * @} - */ -/* Exported functions --------------------------------------------------------*/ -/** @addtogroup MMC_Exported_Functions - * @{ - */ - -/** @addtogroup MMC_Exported_Functions_Group1 - * @brief Initialization and de-initialization functions - * -@verbatim - ============================================================================== - ##### Initialization and de-initialization functions ##### - ============================================================================== - [..] - This section provides functions allowing to initialize/de-initialize the MMC - card device to be ready for use. - -@endverbatim - * @{ - */ - -/** - * @brief Initializes the MMC according to the specified parameters in the - MMC_HandleTypeDef and create the associated handle. - * @param hmmc: Pointer to the MMC handle - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_Init(MMC_HandleTypeDef *hmmc) -{ - /* Check the MMC handle allocation */ - if (hmmc == NULL) - { - return HAL_ERROR; - } - - /* Check the parameters */ - assert_param(IS_SDMMC_ALL_INSTANCE(hmmc->Instance)); - assert_param(IS_SDMMC_CLOCK_EDGE(hmmc->Init.ClockEdge)); - assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hmmc->Init.ClockPowerSave)); - assert_param(IS_SDMMC_BUS_WIDE(hmmc->Init.BusWide)); - assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hmmc->Init.HardwareFlowControl)); - assert_param(IS_SDMMC_CLKDIV(hmmc->Init.ClockDiv)); - - if (hmmc->State == HAL_MMC_STATE_RESET) - { - /* Allocate lock resource and initialize it */ - hmmc->Lock = HAL_UNLOCKED; -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - /* Reset Callback pointers in HAL_MMC_STATE_RESET only */ - hmmc->TxCpltCallback = HAL_MMC_TxCpltCallback; - hmmc->RxCpltCallback = HAL_MMC_RxCpltCallback; - hmmc->ErrorCallback = HAL_MMC_ErrorCallback; - hmmc->AbortCpltCallback = HAL_MMC_AbortCallback; - hmmc->Read_DMADblBuf0CpltCallback = HAL_MMCEx_Read_DMADoubleBuf0CpltCallback; - hmmc->Read_DMADblBuf1CpltCallback = HAL_MMCEx_Read_DMADoubleBuf1CpltCallback; - hmmc->Write_DMADblBuf0CpltCallback = HAL_MMCEx_Write_DMADoubleBuf0CpltCallback; - hmmc->Write_DMADblBuf1CpltCallback = HAL_MMCEx_Write_DMADoubleBuf1CpltCallback; - - if (hmmc->MspInitCallback == NULL) - { - hmmc->MspInitCallback = HAL_MMC_MspInit; - } - - /* Init the low level hardware */ - hmmc->MspInitCallback(hmmc); -#else - /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */ - HAL_MMC_MspInit(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize the Card parameters */ - if (HAL_MMC_InitCard(hmmc) == HAL_ERROR) - { - return HAL_ERROR; - } - - /* Initialize the error code */ - hmmc->ErrorCode = HAL_DMA_ERROR_NONE; - - /* Initialize the MMC operation */ - hmmc->Context = MMC_CONTEXT_NONE; - - /* Initialize the MMC state */ - hmmc->State = HAL_MMC_STATE_READY; - - /* Configure bus width */ - if (hmmc->Init.BusWide != SDMMC_BUS_WIDE_1B) - { - if (HAL_MMC_ConfigWideBusOperation(hmmc, hmmc->Init.BusWide) != HAL_OK) - { - return HAL_ERROR; - } - } - - return HAL_OK; -} - -/** - * @brief Initializes the MMC Card. - * @param hmmc: Pointer to MMC handle - * @note This function initializes the MMC card. It could be used when a card - re-initialization is needed. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_InitCard(MMC_HandleTypeDef *hmmc) -{ - uint32_t errorstate; - MMC_InitTypeDef Init; - uint32_t sdmmc_clk; - - /* Default SDMMC peripheral configuration for MMC card initialization */ - Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING; - Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE; - Init.BusWide = SDMMC_BUS_WIDE_1B; - Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE; - - /* Init Clock should be less or equal to 400Khz*/ - sdmmc_clk = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SDMMC); - if (sdmmc_clk == 0U) - { - hmmc->State = HAL_MMC_STATE_READY; - hmmc->ErrorCode = SDMMC_ERROR_INVALID_PARAMETER; - return HAL_ERROR; - } - Init.ClockDiv = sdmmc_clk / (2U * MMC_INIT_FREQ); - -#if (USE_SD_TRANSCEIVER != 0U) - Init.TranceiverPresent = SDMMC_TRANSCEIVER_NOT_PRESENT; -#endif /* USE_SD_TRANSCEIVER */ - - /* Initialize SDMMC peripheral interface with default configuration */ - (void)SDMMC_Init(hmmc->Instance, Init); - - /* Set Power State to ON */ - (void)SDMMC_PowerState_ON(hmmc->Instance); - - /* wait 74 Cycles: required power up waiting time before starting - the MMC initialization sequence */ - if (Init.ClockDiv != 0U) - { - sdmmc_clk = sdmmc_clk / (2U * Init.ClockDiv); - } - - if (sdmmc_clk != 0U) - { - HAL_Delay(1U + (74U * 1000U / (sdmmc_clk))); - } - - /* Identify card operating voltage */ - errorstate = MMC_PowerON(hmmc); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->State = HAL_MMC_STATE_READY; - hmmc->ErrorCode |= errorstate; - return HAL_ERROR; - } - - /* Card initialization */ - errorstate = MMC_InitCard(hmmc); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->State = HAL_MMC_STATE_READY; - hmmc->ErrorCode |= errorstate; - return HAL_ERROR; - } - - /* Set Block Size for Card */ - errorstate = SDMMC_CmdBlockLength(hmmc->Instance, MMC_BLOCKSIZE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - return HAL_OK; -} - -/** - * @brief De-Initializes the MMC card. - * @param hmmc: Pointer to MMC handle - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_DeInit(MMC_HandleTypeDef *hmmc) -{ - /* Check the MMC handle allocation */ - if (hmmc == NULL) - { - return HAL_ERROR; - } - - /* Check the parameters */ - assert_param(IS_SDMMC_ALL_INSTANCE(hmmc->Instance)); - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Set MMC power state to off */ - MMC_PowerOFF(hmmc); - -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - if (hmmc->MspDeInitCallback == NULL) - { - hmmc->MspDeInitCallback = HAL_MMC_MspDeInit; - } - - /* DeInit the low level hardware */ - hmmc->MspDeInitCallback(hmmc); -#else - /* De-Initialize the MSP layer */ - HAL_MMC_MspDeInit(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - hmmc->State = HAL_MMC_STATE_RESET; - - return HAL_OK; -} - -/** - * @brief Initializes the MMC MSP. - * @param hmmc: Pointer to MMC handle - * @retval None - */ -__weak void HAL_MMC_MspInit(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function Should not be modified, when the callback is needed, - the HAL_MMC_MspInit could be implemented in the user file - */ -} - -/** - * @brief De-Initialize MMC MSP. - * @param hmmc: Pointer to MMC handle - * @retval None - */ -__weak void HAL_MMC_MspDeInit(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function Should not be modified, when the callback is needed, - the HAL_MMC_MspDeInit could be implemented in the user file - */ -} - -/** - * @} - */ - -/** @addtogroup MMC_Exported_Functions_Group2 - * @brief Data transfer functions - * -@verbatim - ============================================================================== - ##### IO operation functions ##### - ============================================================================== - [..] - This subsection provides a set of functions allowing to manage the data - transfer from/to MMC card. - -@endverbatim - * @{ - */ - -/** - * @brief Reads block(s) from a specified address in a card. The Data transfer - * is managed by polling mode. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @param hmmc: Pointer to MMC handle - * @param pData: pointer to the buffer that will contain the received data - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Number of MMC blocks to read - * @param Timeout: Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_ReadBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks, - uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t data; - uint32_t dataremaining; - uint32_t add = BlockAdd; - uint8_t *tempbuff = pData; - - if (NULL == pData) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) - & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= MMC_BLOCKSIZE; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = NumberOfBlocks * MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Read block(s) in polling mode */ - if (NumberOfBlocks > 1U) - { - hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK; - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add); - } - else - { - hmmc->Context = MMC_CONTEXT_READ_SINGLE_BLOCK; - - /* Read Single Block command */ - errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add); - } - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Poll on SDMMC flags */ - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hmmc->Instance); - *tempbuff = (uint8_t)(data & 0xFFU); - tempbuff++; - *tempbuff = (uint8_t)((data >> 8U) & 0xFFU); - tempbuff++; - *tempbuff = (uint8_t)((data >> 16U) & 0xFFU); - tempbuff++; - *tempbuff = (uint8_t)((data >> 24U) & 0xFFU); - tempbuff++; - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Send stop transmission command in case of multiblock read */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U)) - { - /* Send stop transmission command */ - errorstate = SDMMC_CmdStopTransfer(hmmc->Instance); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - } - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXOVERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - return HAL_OK; - } - else - { - hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY; - return HAL_ERROR; - } -} - -/** - * @brief Allows to write block(s) to a specified address in a card. The Data - * transfer is managed by polling mode. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @param hmmc: Pointer to MMC handle - * @param pData: pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of MMC blocks to write - * @param Timeout: Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_WriteBlocks(MMC_HandleTypeDef *hmmc, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks, uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t data; - uint32_t dataremaining; - uint32_t add = BlockAdd; - const uint8_t *tempbuff = pData; - - if (NULL == pData) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= MMC_BLOCKSIZE; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = NumberOfBlocks * MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - if (NumberOfBlocks > 1U) - { - hmmc->Context = MMC_CONTEXT_WRITE_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, add); - } - else - { - hmmc->Context = MMC_CONTEXT_WRITE_SINGLE_BLOCK; - - /* Write Single Block command */ - errorstate = SDMMC_CmdWriteSingleBlock(hmmc->Instance, add); - } - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Write block(s) in polling mode */ - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*tempbuff); - tempbuff++; - data |= ((uint32_t)(*tempbuff) << 8U); - tempbuff++; - data |= ((uint32_t)(*tempbuff) << 16U); - tempbuff++; - data |= ((uint32_t)(*tempbuff) << 24U); - tempbuff++; - (void)SDMMC_WriteFIFO(hmmc->Instance, &data); - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Send stop transmission command in case of multiblock write */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U)) - { - /* Send stop transmission command */ - errorstate = SDMMC_CmdStopTransfer(hmmc->Instance); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - } - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXUNDERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - return HAL_OK; - } - else - { - hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY; - return HAL_ERROR; - } -} - -/** - * @brief Reads block(s) from a specified address in a card. The Data transfer - * is managed in interrupt mode. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @note You could also check the IT transfer process through the MMC Rx - * interrupt event. - * @param hmmc: Pointer to MMC handle - * @param pData: Pointer to the buffer that will contain the received data - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Number of blocks to read. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_ReadBlocks_IT(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - hmmc->pRxBuffPtr = pData; - hmmc->RxXferSize = MMC_BLOCKSIZE * NumberOfBlocks; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= MMC_BLOCKSIZE; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Read Blocks in IT mode */ - if (NumberOfBlocks > 1U) - { - hmmc->Context = (MMC_CONTEXT_READ_MULTIPLE_BLOCK | MMC_CONTEXT_IT); - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add); - } - else - { - hmmc->Context = (MMC_CONTEXT_READ_SINGLE_BLOCK | MMC_CONTEXT_IT); - - /* Read Single Block command */ - errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add); - } - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - __HAL_MMC_ENABLE_IT(hmmc, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND | - SDMMC_FLAG_RXFIFOHF)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Writes block(s) to a specified address in a card. The Data transfer - * is managed in interrupt mode. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @note You could also check the IT transfer process through the MMC Tx - * interrupt event. - * @param hmmc: Pointer to MMC handle - * @param pData: Pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of blocks to write - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_WriteBlocks_IT(MMC_HandleTypeDef *hmmc, const uint8_t *pData, - uint32_t BlockAdd, uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - hmmc->pTxBuffPtr = pData; - hmmc->TxXferSize = MMC_BLOCKSIZE * NumberOfBlocks; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= MMC_BLOCKSIZE; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - if (NumberOfBlocks > 1U) - { - hmmc->Context = (MMC_CONTEXT_WRITE_MULTIPLE_BLOCK | MMC_CONTEXT_IT); - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, add); - } - else - { - hmmc->Context = (MMC_CONTEXT_WRITE_SINGLE_BLOCK | MMC_CONTEXT_IT); - - /* Write Single Block command */ - errorstate = SDMMC_CmdWriteSingleBlock(hmmc->Instance, add); - } - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Enable transfer interrupts */ - __HAL_MMC_ENABLE_IT(hmmc, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND | - SDMMC_FLAG_TXFIFOHE)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Reads block(s) from a specified address in a card. The Data transfer - * is managed by DMA mode. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @note You could also check the DMA transfer process through the MMC Rx - * interrupt event. - * @param hmmc: Pointer MMC handle - * @param pData: Pointer to the buffer that will contain the received data - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Number of blocks to read. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_ReadBlocks_DMA(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_DMA_ERROR_NONE; - - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - hmmc->pRxBuffPtr = pData; - hmmc->RxXferSize = MMC_BLOCKSIZE * NumberOfBlocks; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= MMC_BLOCKSIZE; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - hmmc->Instance->IDMABASE0 = (uint32_t) pData ; - hmmc->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF; - - /* Read Blocks in DMA mode */ - if (NumberOfBlocks > 1U) - { - hmmc->Context = (MMC_CONTEXT_READ_MULTIPLE_BLOCK | MMC_CONTEXT_DMA); - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add); - } - else - { - hmmc->Context = (MMC_CONTEXT_READ_SINGLE_BLOCK | MMC_CONTEXT_DMA); - - /* Read Single Block command */ - errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add); - } - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode = errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Enable transfer interrupts */ - __HAL_MMC_ENABLE_IT(hmmc, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Writes block(s) to a specified address in a card. The Data transfer - * is managed by DMA mode. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @note You could also check the DMA transfer process through the MMC Tx - * interrupt event. - * @param hmmc: Pointer to MMC handle - * @param pData: Pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of blocks to write - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_WriteBlocks_DMA(MMC_HandleTypeDef *hmmc, const uint8_t *pData, - uint32_t BlockAdd, uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - hmmc->pTxBuffPtr = pData; - hmmc->TxXferSize = MMC_BLOCKSIZE * NumberOfBlocks; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= MMC_BLOCKSIZE; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - hmmc->Instance->IDMABASE0 = (uint32_t) pData ; - hmmc->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF; - - /* Write Blocks in Polling mode */ - if (NumberOfBlocks > 1U) - { - hmmc->Context = (MMC_CONTEXT_WRITE_MULTIPLE_BLOCK | MMC_CONTEXT_DMA); - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, add); - } - else - { - hmmc->Context = (MMC_CONTEXT_WRITE_SINGLE_BLOCK | MMC_CONTEXT_DMA); - - /* Write Single Block command */ - errorstate = SDMMC_CmdWriteSingleBlock(hmmc->Instance, add); - } - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Enable transfer interrupts */ - __HAL_MMC_ENABLE_IT(hmmc, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Erases the specified memory area of the given MMC card. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @param hmmc: Pointer to MMC handle - * @param BlockStartAdd: Start Block address - * @param BlockEndAdd: End Block address - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_Erase(MMC_HandleTypeDef *hmmc, uint32_t BlockStartAdd, uint32_t BlockEndAdd) -{ - uint32_t errorstate; - uint32_t start_add = BlockStartAdd; - uint32_t end_add = BlockEndAdd; - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - if (end_add < start_add) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (end_add > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) - & 0x000000FFU) != 0x0U) - { - if (((start_add % 8U) != 0U) || ((end_add % 8U) != 0U)) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Check if the card command class supports erase command */ - if (((hmmc->MmcCard.Class) & SDMMC_CCCC_ERASE) == 0U) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_REQUEST_NOT_APPLICABLE; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - if ((SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_LOCK_UNLOCK_FAILED; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - start_add *= MMC_BLOCKSIZE; - end_add *= MMC_BLOCKSIZE; - } - - /* Send CMD35 MMC_ERASE_GRP_START with argument as addr */ - errorstate = SDMMC_CmdEraseStartAdd(hmmc->Instance, start_add); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Send CMD36 MMC_ERASE_GRP_END with argument as addr */ - errorstate = SDMMC_CmdEraseEndAdd(hmmc->Instance, end_add); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Send CMD38 ERASE */ - errorstate = SDMMC_CmdErase(hmmc->Instance, 0UL); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - hmmc->State = HAL_MMC_STATE_READY; - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief This function handles MMC card interrupt request. - * @param hmmc: Pointer to MMC handle - * @retval None - */ -void HAL_MMC_IRQHandler(MMC_HandleTypeDef *hmmc) -{ - uint32_t errorstate; - uint32_t context = hmmc->Context; - - /* Check for SDMMC interrupt flags */ - if ((__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF) != RESET) && ((context & MMC_CONTEXT_IT) != 0U)) - { - MMC_Read_IT(hmmc); - } - - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DATAEND) != RESET) - { - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_DATAEND); - - __HAL_MMC_DISABLE_IT(hmmc, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR | SDMMC_IT_TXFIFOHE | \ - SDMMC_IT_RXFIFOHF); - - __HAL_MMC_DISABLE_IT(hmmc, SDMMC_IT_IDMABTC); - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - if ((context & MMC_CONTEXT_DMA) != 0U) - { - hmmc->Instance->DLEN = 0; - hmmc->Instance->DCTRL = 0; - hmmc->Instance->IDMACTRL = SDMMC_DISABLE_IDMA ; - - /* Stop Transfer for Write Multi blocks or Read Multi blocks */ - if (((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)) - { - errorstate = SDMMC_CmdStopTransfer(hmmc->Instance); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->ErrorCallback(hmmc); -#else - HAL_MMC_ErrorCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - if (((context & MMC_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)) - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->TxCpltCallback(hmmc); -#else - HAL_MMC_TxCpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - if (((context & MMC_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) != 0U)) - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->RxCpltCallback(hmmc); -#else - HAL_MMC_RxCpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - } - else if ((context & MMC_CONTEXT_IT) != 0U) - { - /* Stop Transfer for Write Multi blocks or Read Multi blocks */ - if (((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)) - { - errorstate = SDMMC_CmdStopTransfer(hmmc->Instance); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->ErrorCallback(hmmc); -#else - HAL_MMC_ErrorCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - if (((context & MMC_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) != 0U)) - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->RxCpltCallback(hmmc); -#else - HAL_MMC_RxCpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - else - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->TxCpltCallback(hmmc); -#else - HAL_MMC_TxCpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - } - else - { - /* Nothing to do */ - } - } - - else if ((__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXFIFOHE) != RESET) && ((context & MMC_CONTEXT_IT) != 0U)) - { - MMC_Write_IT(hmmc); - } - - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL | - SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_RXOVERR | SDMMC_FLAG_TXUNDERR) != RESET) - { - /* Set Error code */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_IT_DCRCFAIL) != RESET) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - } - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_IT_DTIMEOUT) != RESET) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - } - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_IT_RXOVERR) != RESET) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN; - } - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_IT_TXUNDERR) != RESET) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN; - } - - /* Clear All flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - /* Disable all interrupts */ - __HAL_MMC_DISABLE_IT(hmmc, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR); - - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - hmmc->Instance->DCTRL |= SDMMC_DCTRL_FIFORST; - hmmc->Instance->CMD |= SDMMC_CMD_CMDSTOP; - hmmc->ErrorCode |= SDMMC_CmdStopTransfer(hmmc->Instance); - hmmc->Instance->CMD &= ~(SDMMC_CMD_CMDSTOP); - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_DABORT); - - if ((context & MMC_CONTEXT_IT) != 0U) - { - /* Set the MMC state to ready to be able to start again the process */ - hmmc->State = HAL_MMC_STATE_READY; -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->ErrorCallback(hmmc); -#else - HAL_MMC_ErrorCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - else if ((context & MMC_CONTEXT_DMA) != 0U) - { - if (hmmc->ErrorCode != HAL_MMC_ERROR_NONE) - { - /* Disable Internal DMA */ - __HAL_MMC_DISABLE_IT(hmmc, SDMMC_IT_IDMABTC); - hmmc->Instance->IDMACTRL = SDMMC_DISABLE_IDMA; - - /* Set the MMC state to ready to be able to start again the process */ - hmmc->State = HAL_MMC_STATE_READY; -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->ErrorCallback(hmmc); -#else - HAL_MMC_ErrorCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - } - else - { - /* Nothing to do */ - } - } - - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_IDMABTC) != RESET) - { - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_IT_IDMABTC); - if (READ_BIT(hmmc->Instance->IDMACTRL, SDMMC_IDMA_IDMABACT) == 0U) - { - /* Current buffer is buffer0, Transfer complete for buffer1 */ - if ((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U) - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->Write_DMADblBuf1CpltCallback(hmmc); -#else - HAL_MMCEx_Write_DMADoubleBuf1CpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - else /* MMC_CONTEXT_READ_MULTIPLE_BLOCK */ - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->Read_DMADblBuf1CpltCallback(hmmc); -#else - HAL_MMCEx_Read_DMADoubleBuf1CpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - } - else /* MMC_DMA_BUFFER1 */ - { - /* Current buffer is buffer1, Transfer complete for buffer0 */ - if ((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U) - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->Write_DMADblBuf0CpltCallback(hmmc); -#else - HAL_MMCEx_Write_DMADoubleBuf0CpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - else /* MMC_CONTEXT_READ_MULTIPLE_BLOCK */ - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->Read_DMADblBuf0CpltCallback(hmmc); -#else - HAL_MMCEx_Read_DMADoubleBuf0CpltCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - } - } - - else - { - /* Nothing to do */ - } -} - -/** - * @brief return the MMC state - * @param hmmc: Pointer to mmc handle - * @retval HAL state - */ -HAL_MMC_StateTypeDef HAL_MMC_GetState(const MMC_HandleTypeDef *hmmc) -{ - return hmmc->State; -} - -/** - * @brief Return the MMC error code - * @param hmmc : Pointer to a MMC_HandleTypeDef structure that contains - * the configuration information. - * @retval MMC Error Code - */ -uint32_t HAL_MMC_GetError(const MMC_HandleTypeDef *hmmc) -{ - return hmmc->ErrorCode; -} - -/** - * @brief Tx Transfer completed callbacks - * @param hmmc: Pointer to MMC handle - * @retval None - */ -__weak void HAL_MMC_TxCpltCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMC_TxCpltCallback can be implemented in the user file - */ -} - -/** - * @brief Rx Transfer completed callbacks - * @param hmmc: Pointer MMC handle - * @retval None - */ -__weak void HAL_MMC_RxCpltCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMC_RxCpltCallback can be implemented in the user file - */ -} - -/** - * @brief MMC error callbacks - * @param hmmc: Pointer MMC handle - * @retval None - */ -__weak void HAL_MMC_ErrorCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMC_ErrorCallback can be implemented in the user file - */ -} - -/** - * @brief MMC Abort callbacks - * @param hmmc: Pointer MMC handle - * @retval None - */ -__weak void HAL_MMC_AbortCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMC_AbortCallback can be implemented in the user file - */ -} - -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) -/** - * @brief Register a User MMC Callback - * To be used instead of the weak (overridden) predefined callback - * @note The HAL_MMC_RegisterCallback() may be called before HAL_MMC_Init() in - * HAL_MMC_STATE_RESET to register callbacks for HAL_MMC_MSP_INIT_CB_ID - * and HAL_MMC_MSP_DEINIT_CB_ID. - * @param hmmc : MMC handle - * @param CallbackId : ID of the callback to be registered - * This parameter can be one of the following values: - * @arg @ref HAL_MMC_TX_CPLT_CB_ID MMC Tx Complete Callback ID - * @arg @ref HAL_MMC_RX_CPLT_CB_ID MMC Rx Complete Callback ID - * @arg @ref HAL_MMC_ERROR_CB_ID MMC Error Callback ID - * @arg @ref HAL_MMC_ABORT_CB_ID MMC Abort Callback ID - * @arg @ref HAL_MMC_READ_DMA_DBL_BUF0_CPLT_CB_ID MMC DMA Rx Double buffer 0 Callback ID - * @arg @ref HAL_MMC_READ_DMA_DBL_BUF1_CPLT_CB_ID MMC DMA Rx Double buffer 1 Callback ID - * @arg @ref HAL_MMC_WRITE_DMA_DBL_BUF0_CPLT_CB_ID MMC DMA Tx Double buffer 0 Callback ID - * @arg @ref HAL_MMC_WRITE_DMA_DBL_BUF1_CPLT_CB_ID MMC DMA Tx Double buffer 1 Callback ID - * @arg @ref HAL_MMC_MSP_INIT_CB_ID MMC MspInit Callback ID - * @arg @ref HAL_MMC_MSP_DEINIT_CB_ID MMC MspDeInit Callback ID - * @param pCallback : pointer to the Callback function - * @retval status - */ -HAL_StatusTypeDef HAL_MMC_RegisterCallback(MMC_HandleTypeDef *hmmc, HAL_MMC_CallbackIDTypeDef CallbackId, - pMMC_CallbackTypeDef pCallback) -{ - HAL_StatusTypeDef status = HAL_OK; - - if (pCallback == NULL) - { - /* Update the error code */ - hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - switch (CallbackId) - { - case HAL_MMC_TX_CPLT_CB_ID : - hmmc->TxCpltCallback = pCallback; - break; - case HAL_MMC_RX_CPLT_CB_ID : - hmmc->RxCpltCallback = pCallback; - break; - case HAL_MMC_ERROR_CB_ID : - hmmc->ErrorCallback = pCallback; - break; - case HAL_MMC_ABORT_CB_ID : - hmmc->AbortCpltCallback = pCallback; - break; - case HAL_MMC_READ_DMA_DBL_BUF0_CPLT_CB_ID : - hmmc->Read_DMADblBuf0CpltCallback = pCallback; - break; - case HAL_MMC_READ_DMA_DBL_BUF1_CPLT_CB_ID : - hmmc->Read_DMADblBuf1CpltCallback = pCallback; - break; - case HAL_MMC_WRITE_DMA_DBL_BUF0_CPLT_CB_ID : - hmmc->Write_DMADblBuf0CpltCallback = pCallback; - break; - case HAL_MMC_WRITE_DMA_DBL_BUF1_CPLT_CB_ID : - hmmc->Write_DMADblBuf1CpltCallback = pCallback; - break; - case HAL_MMC_MSP_INIT_CB_ID : - hmmc->MspInitCallback = pCallback; - break; - case HAL_MMC_MSP_DEINIT_CB_ID : - hmmc->MspDeInitCallback = pCallback; - break; - default : - /* Update the error code */ - hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else if (hmmc->State == HAL_MMC_STATE_RESET) - { - switch (CallbackId) - { - case HAL_MMC_MSP_INIT_CB_ID : - hmmc->MspInitCallback = pCallback; - break; - case HAL_MMC_MSP_DEINIT_CB_ID : - hmmc->MspDeInitCallback = pCallback; - break; - default : - /* Update the error code */ - hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else - { - /* Update the error code */ - hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - } - - return status; -} - -/** - * @brief Unregister a User MMC Callback - * MMC Callback is redirected to the weak (overridden) predefined callback - * @note The HAL_MMC_UnRegisterCallback() may be called before HAL_MMC_Init() in - * HAL_MMC_STATE_RESET to register callbacks for HAL_MMC_MSP_INIT_CB_ID - * and HAL_MMC_MSP_DEINIT_CB_ID. - * @param hmmc : MMC handle - * @param CallbackId : ID of the callback to be unregistered - * This parameter can be one of the following values: - * @arg @ref HAL_MMC_TX_CPLT_CB_ID MMC Tx Complete Callback ID - * @arg @ref HAL_MMC_RX_CPLT_CB_ID MMC Rx Complete Callback ID - * @arg @ref HAL_MMC_ERROR_CB_ID MMC Error Callback ID - * @arg @ref HAL_MMC_ABORT_CB_ID MMC Abort Callback ID - * @arg @ref HAL_MMC_READ_DMA_DBL_BUF0_CPLT_CB_ID MMC DMA Rx Double buffer 0 Callback ID - * @arg @ref HAL_MMC_READ_DMA_DBL_BUF1_CPLT_CB_ID MMC DMA Rx Double buffer 1 Callback ID - * @arg @ref HAL_MMC_WRITE_DMA_DBL_BUF0_CPLT_CB_ID MMC DMA Tx Double buffer 0 Callback ID - * @arg @ref HAL_MMC_WRITE_DMA_DBL_BUF1_CPLT_CB_ID MMC DMA Tx Double buffer 1 Callback ID - * @arg @ref HAL_MMC_MSP_INIT_CB_ID MMC MspInit Callback ID - * @arg @ref HAL_MMC_MSP_DEINIT_CB_ID MMC MspDeInit Callback ID - * @retval status - */ -HAL_StatusTypeDef HAL_MMC_UnRegisterCallback(MMC_HandleTypeDef *hmmc, HAL_MMC_CallbackIDTypeDef CallbackId) -{ - HAL_StatusTypeDef status = HAL_OK; - - if (hmmc->State == HAL_MMC_STATE_READY) - { - switch (CallbackId) - { - case HAL_MMC_TX_CPLT_CB_ID : - hmmc->TxCpltCallback = HAL_MMC_TxCpltCallback; - break; - case HAL_MMC_RX_CPLT_CB_ID : - hmmc->RxCpltCallback = HAL_MMC_RxCpltCallback; - break; - case HAL_MMC_ERROR_CB_ID : - hmmc->ErrorCallback = HAL_MMC_ErrorCallback; - break; - case HAL_MMC_ABORT_CB_ID : - hmmc->AbortCpltCallback = HAL_MMC_AbortCallback; - break; - case HAL_MMC_READ_DMA_DBL_BUF0_CPLT_CB_ID : - hmmc->Read_DMADblBuf0CpltCallback = HAL_MMCEx_Read_DMADoubleBuf0CpltCallback; - break; - case HAL_MMC_READ_DMA_DBL_BUF1_CPLT_CB_ID : - hmmc->Read_DMADblBuf1CpltCallback = HAL_MMCEx_Read_DMADoubleBuf1CpltCallback; - break; - case HAL_MMC_WRITE_DMA_DBL_BUF0_CPLT_CB_ID : - hmmc->Write_DMADblBuf0CpltCallback = HAL_MMCEx_Write_DMADoubleBuf0CpltCallback; - break; - case HAL_MMC_WRITE_DMA_DBL_BUF1_CPLT_CB_ID : - hmmc->Write_DMADblBuf1CpltCallback = HAL_MMCEx_Write_DMADoubleBuf1CpltCallback; - break; - case HAL_MMC_MSP_INIT_CB_ID : - hmmc->MspInitCallback = HAL_MMC_MspInit; - break; - case HAL_MMC_MSP_DEINIT_CB_ID : - hmmc->MspDeInitCallback = HAL_MMC_MspDeInit; - break; - default : - /* Update the error code */ - hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else if (hmmc->State == HAL_MMC_STATE_RESET) - { - switch (CallbackId) - { - case HAL_MMC_MSP_INIT_CB_ID : - hmmc->MspInitCallback = HAL_MMC_MspInit; - break; - case HAL_MMC_MSP_DEINIT_CB_ID : - hmmc->MspDeInitCallback = HAL_MMC_MspDeInit; - break; - default : - /* Update the error code */ - hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else - { - /* Update the error code */ - hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - } - - return status; -} -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - -/** - * @} - */ - -/** @addtogroup MMC_Exported_Functions_Group3 - * @brief management functions - * -@verbatim - ============================================================================== - ##### Peripheral Control functions ##### - ============================================================================== - [..] - This subsection provides a set of functions allowing to control the MMC card - operations and get the related information - -@endverbatim - * @{ - */ - -/** - * @brief Returns information the information of the card which are stored on - * the CID register. - * @param hmmc: Pointer to MMC handle - * @param pCID: Pointer to a HAL_MMC_CIDTypedef structure that - * contains all CID register parameters - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_GetCardCID(const MMC_HandleTypeDef *hmmc, HAL_MMC_CardCIDTypeDef *pCID) -{ - pCID->ManufacturerID = (uint8_t)((hmmc->CID[0] & 0xFF000000U) >> 24U); - - pCID->OEM_AppliID = (uint16_t)((hmmc->CID[0] & 0x00FFFF00U) >> 8U); - - pCID->ProdName1 = (((hmmc->CID[0] & 0x000000FFU) << 24U) | ((hmmc->CID[1] & 0xFFFFFF00U) >> 8U)); - - pCID->ProdName2 = (uint8_t)(hmmc->CID[1] & 0x000000FFU); - - pCID->ProdRev = (uint8_t)((hmmc->CID[2] & 0xFF000000U) >> 24U); - - pCID->ProdSN = (((hmmc->CID[2] & 0x00FFFFFFU) << 8U) | ((hmmc->CID[3] & 0xFF000000U) >> 24U)); - - pCID->Reserved1 = (uint8_t)((hmmc->CID[3] & 0x00F00000U) >> 20U); - - pCID->ManufactDate = (uint16_t)((hmmc->CID[3] & 0x000FFF00U) >> 8U); - - pCID->CID_CRC = (uint8_t)((hmmc->CID[3] & 0x000000FEU) >> 1U); - - pCID->Reserved2 = 1U; - - return HAL_OK; -} - -/** - * @brief Returns information the information of the card which are stored on - * the CSD register. - * @param hmmc: Pointer to MMC handle - * @param pCSD: Pointer to a HAL_MMC_CardCSDTypeDef structure that - * contains all CSD register parameters - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_GetCardCSD(MMC_HandleTypeDef *hmmc, HAL_MMC_CardCSDTypeDef *pCSD) -{ - uint32_t block_nbr = 0; - - pCSD->CSDStruct = (uint8_t)((hmmc->CSD[0] & 0xC0000000U) >> 30U); - - pCSD->SysSpecVersion = (uint8_t)((hmmc->CSD[0] & 0x3C000000U) >> 26U); - - pCSD->Reserved1 = (uint8_t)((hmmc->CSD[0] & 0x03000000U) >> 24U); - - pCSD->TAAC = (uint8_t)((hmmc->CSD[0] & 0x00FF0000U) >> 16U); - - pCSD->NSAC = (uint8_t)((hmmc->CSD[0] & 0x0000FF00U) >> 8U); - - pCSD->MaxBusClkFrec = (uint8_t)(hmmc->CSD[0] & 0x000000FFU); - - pCSD->CardComdClasses = (uint16_t)((hmmc->CSD[1] & 0xFFF00000U) >> 20U); - - pCSD->RdBlockLen = (uint8_t)((hmmc->CSD[1] & 0x000F0000U) >> 16U); - - pCSD->PartBlockRead = (uint8_t)((hmmc->CSD[1] & 0x00008000U) >> 15U); - - pCSD->WrBlockMisalign = (uint8_t)((hmmc->CSD[1] & 0x00004000U) >> 14U); - - pCSD->RdBlockMisalign = (uint8_t)((hmmc->CSD[1] & 0x00002000U) >> 13U); - - pCSD->DSRImpl = (uint8_t)((hmmc->CSD[1] & 0x00001000U) >> 12U); - - pCSD->Reserved2 = 0U; /*!< Reserved */ - - if (MMC_ReadExtCSD(hmmc, &block_nbr, 212, 0x0FFFFFFFU) != HAL_OK) /* Field SEC_COUNT [215:212] */ - { - return HAL_ERROR; - } - - if (hmmc->MmcCard.CardType == MMC_LOW_CAPACITY_CARD) - { - pCSD->DeviceSize = (((hmmc->CSD[1] & 0x000003FFU) << 2U) | ((hmmc->CSD[2] & 0xC0000000U) >> 30U)); - - pCSD->MaxRdCurrentVDDMin = (uint8_t)((hmmc->CSD[2] & 0x38000000U) >> 27U); - - pCSD->MaxRdCurrentVDDMax = (uint8_t)((hmmc->CSD[2] & 0x07000000U) >> 24U); - - pCSD->MaxWrCurrentVDDMin = (uint8_t)((hmmc->CSD[2] & 0x00E00000U) >> 21U); - - pCSD->MaxWrCurrentVDDMax = (uint8_t)((hmmc->CSD[2] & 0x001C0000U) >> 18U); - - pCSD->DeviceSizeMul = (uint8_t)((hmmc->CSD[2] & 0x00038000U) >> 15U); - - hmmc->MmcCard.BlockNbr = (pCSD->DeviceSize + 1U) ; - hmmc->MmcCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U)); - hmmc->MmcCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU)); - - hmmc->MmcCard.LogBlockNbr = (hmmc->MmcCard.BlockNbr) * ((hmmc->MmcCard.BlockSize) / MMC_BLOCKSIZE); - hmmc->MmcCard.LogBlockSize = MMC_BLOCKSIZE; - } - else if (hmmc->MmcCard.CardType == MMC_HIGH_CAPACITY_CARD) - { - hmmc->MmcCard.BlockNbr = block_nbr; - hmmc->MmcCard.LogBlockNbr = hmmc->MmcCard.BlockNbr; - hmmc->MmcCard.BlockSize = MMC_BLOCKSIZE; - hmmc->MmcCard.LogBlockSize = hmmc->MmcCard.BlockSize; - } - else - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_UNSUPPORTED_FEATURE; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - pCSD->EraseGrSize = (uint8_t)((hmmc->CSD[2] & 0x00004000U) >> 14U); - - pCSD->EraseGrMul = (uint8_t)((hmmc->CSD[2] & 0x00003F80U) >> 7U); - - pCSD->WrProtectGrSize = (uint8_t)(hmmc->CSD[2] & 0x0000007FU); - - pCSD->WrProtectGrEnable = (uint8_t)((hmmc->CSD[3] & 0x80000000U) >> 31U); - - pCSD->ManDeflECC = (uint8_t)((hmmc->CSD[3] & 0x60000000U) >> 29U); - - pCSD->WrSpeedFact = (uint8_t)((hmmc->CSD[3] & 0x1C000000U) >> 26U); - - pCSD->MaxWrBlockLen = (uint8_t)((hmmc->CSD[3] & 0x03C00000U) >> 22U); - - pCSD->WriteBlockPaPartial = (uint8_t)((hmmc->CSD[3] & 0x00200000U) >> 21U); - - pCSD->Reserved3 = 0; - - pCSD->ContentProtectAppli = (uint8_t)((hmmc->CSD[3] & 0x00010000U) >> 16U); - - pCSD->FileFormatGroup = (uint8_t)((hmmc->CSD[3] & 0x00008000U) >> 15U); - - pCSD->CopyFlag = (uint8_t)((hmmc->CSD[3] & 0x00004000U) >> 14U); - - pCSD->PermWrProtect = (uint8_t)((hmmc->CSD[3] & 0x00002000U) >> 13U); - - pCSD->TempWrProtect = (uint8_t)((hmmc->CSD[3] & 0x00001000U) >> 12U); - - pCSD->FileFormat = (uint8_t)((hmmc->CSD[3] & 0x00000C00U) >> 10U); - - pCSD->ECC = (uint8_t)((hmmc->CSD[3] & 0x00000300U) >> 8U); - - pCSD->CSD_CRC = (uint8_t)((hmmc->CSD[3] & 0x000000FEU) >> 1U); - - pCSD->Reserved4 = 1; - - return HAL_OK; -} - -/** - * @brief Gets the MMC card info. - * @param hmmc: Pointer to MMC handle - * @param pCardInfo: Pointer to the HAL_MMC_CardInfoTypeDef structure that - * will contain the MMC card status information - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_GetCardInfo(const MMC_HandleTypeDef *hmmc, HAL_MMC_CardInfoTypeDef *pCardInfo) -{ - pCardInfo->CardType = (uint32_t)(hmmc->MmcCard.CardType); - pCardInfo->Class = (uint32_t)(hmmc->MmcCard.Class); - pCardInfo->RelCardAdd = (uint32_t)(hmmc->MmcCard.RelCardAdd); - pCardInfo->BlockNbr = (uint32_t)(hmmc->MmcCard.BlockNbr); - pCardInfo->BlockSize = (uint32_t)(hmmc->MmcCard.BlockSize); - pCardInfo->LogBlockNbr = (uint32_t)(hmmc->MmcCard.LogBlockNbr); - pCardInfo->LogBlockSize = (uint32_t)(hmmc->MmcCard.LogBlockSize); - - return HAL_OK; -} - -/** - * @brief Returns information the information of the card which are stored on - * the Extended CSD register. - * @param hmmc Pointer to MMC handle - * @param pExtCSD Pointer to a memory area (512 bytes) that contains all - * Extended CSD register parameters - * @param Timeout Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_GetCardExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pExtCSD, uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t *tmp_buf; - - if (NULL == pExtCSD) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0; - - /* Initiaize the destination pointer */ - tmp_buf = pExtCSD; - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Send ExtCSD Read command to Card */ - errorstate = SDMMC_CmdSendEXTCSD(hmmc->Instance, 0); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Poll on SDMMC flags */ - while (!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXOVERR | - SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - *tmp_buf = SDMMC_ReadFIFO(hmmc->Instance); - tmp_buf++; - } - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXOVERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - hmmc->State = HAL_MMC_STATE_READY; - } - - return HAL_OK; -} - -/** - * @brief Enables wide bus operation for the requested card if supported by - * card. - * @param hmmc: Pointer to MMC handle - * @param WideMode: Specifies the MMC card wide bus mode - * This parameter can be one of the following values: - * @arg SDMMC_BUS_WIDE_8B: 8-bit data transfer - * @arg SDMMC_BUS_WIDE_4B: 4-bit data transfer - * @arg SDMMC_BUS_WIDE_1B: 1-bit data transfer - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_ConfigWideBusOperation(MMC_HandleTypeDef *hmmc, uint32_t WideMode) -{ - uint32_t count; - SDMMC_InitTypeDef Init; - uint32_t errorstate; - uint32_t response = 0U; - - /* Check the parameters */ - assert_param(IS_SDMMC_BUS_WIDE(WideMode)); - - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Check and update the power class if needed */ - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_BUSSPEED) != 0U) - { - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_DDR) != 0U) - { - errorstate = MMC_PwrClassUpdate(hmmc, WideMode, SDMMC_SPEED_MODE_DDR); - } - else - { - errorstate = MMC_PwrClassUpdate(hmmc, WideMode, SDMMC_SPEED_MODE_HIGH); - } - } - else - { - errorstate = MMC_PwrClassUpdate(hmmc, WideMode, SDMMC_SPEED_MODE_DEFAULT); - } - - if (errorstate == HAL_MMC_ERROR_NONE) - { - if (WideMode == SDMMC_BUS_WIDE_8B) - { - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70200U); - } - else if (WideMode == SDMMC_BUS_WIDE_4B) - { - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70100U); - } - else if (WideMode == SDMMC_BUS_WIDE_1B) - { - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70000U); - } - else - { - /* WideMode is not a valid argument*/ - errorstate = HAL_MMC_ERROR_PARAM; - } - - /* Check for switch error and violation of the trial number of sending CMD 13 */ - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE)) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } - else - { - /* Configure the SDMMC peripheral */ - Init = hmmc->Init; - Init.BusWide = WideMode; - (void)SDMMC_Init(hmmc->Instance, Init); - } - } - else if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else - { - /* Nothing to do */ - } - } - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - return HAL_ERROR; - } - - return HAL_OK; -} - -/** - * @brief Configure the speed bus mode - * @param hmmc: Pointer to the MMC handle - * @param SpeedMode: Specifies the MMC card speed bus mode - * This parameter can be one of the following values: - * @arg SDMMC_SPEED_MODE_AUTO: Max speed mode supported by the card - * @arg SDMMC_SPEED_MODE_DEFAULT: Default Speed (MMC @ 26MHz) - * @arg SDMMC_SPEED_MODE_HIGH: High Speed (MMC @ 52 MHz) - * @arg SDMMC_SPEED_MODE_DDR: High Speed DDR (MMC DDR @ 52 MHz) - * @retval HAL status - */ - -HAL_StatusTypeDef HAL_MMC_ConfigSpeedBusOperation(MMC_HandleTypeDef *hmmc, uint32_t SpeedMode) -{ - uint32_t tickstart; - HAL_StatusTypeDef status = HAL_OK; - uint32_t device_type; - uint32_t errorstate; - - /* Check the parameters */ - assert_param(IS_SDMMC_SPEED_MODE(SpeedMode)); - - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Field DEVICE_TYPE [196 = 49*4] of Extended CSD register */ - device_type = (hmmc->Ext_CSD[49] & 0x000000FFU); - - switch (SpeedMode) - { - case SDMMC_SPEED_MODE_AUTO: - { - if (((hmmc->Instance->CLKCR & SDMMC_CLKCR_WIDBUS) != 0U) && ((device_type & 0x04U) != 0U)) - { - /* High Speed DDR mode allowed */ - errorstate = MMC_HighSpeed(hmmc, ENABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - else - { - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_CLKDIV) != 0U) - { - /* DDR mode not supported with CLKDIV = 0 */ - errorstate = MMC_DDR_Mode(hmmc, ENABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - } - } - } - else if ((device_type & 0x02U) != 0U) - { - /* High Speed mode allowed */ - errorstate = MMC_HighSpeed(hmmc, ENABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - } - else - { - /* Nothing to do : keep current speed */ - } - break; - } - case SDMMC_SPEED_MODE_DDR: - { - if (((hmmc->Instance->CLKCR & SDMMC_CLKCR_WIDBUS) != 0U) && ((device_type & 0x04U) != 0U)) - { - /* High Speed DDR mode allowed */ - errorstate = MMC_HighSpeed(hmmc, ENABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - else - { - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_CLKDIV) != 0U) - { - /* DDR mode not supported with CLKDIV = 0 */ - errorstate = MMC_DDR_Mode(hmmc, ENABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - } - } - } - else - { - /* High Speed DDR mode not allowed */ - hmmc->ErrorCode |= HAL_MMC_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_HIGH: - { - if ((device_type & 0x02U) != 0U) - { - /* High Speed mode allowed */ - errorstate = MMC_HighSpeed(hmmc, ENABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - } - else - { - /* High Speed mode not allowed */ - hmmc->ErrorCode |= HAL_MMC_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_DEFAULT: - { - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_DDR) != 0U) - { - /* High Speed DDR mode activated */ - errorstate = MMC_DDR_Mode(hmmc, DISABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - } - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_BUSSPEED) != 0U) - { - /* High Speed mode activated */ - errorstate = MMC_HighSpeed(hmmc, DISABLE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - } - break; - } - default: - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - status = HAL_ERROR; - break; - } - - /* Verify that MMC card is ready to use after Speed mode switch*/ - tickstart = HAL_GetTick(); - while ((HAL_MMC_GetCardState(hmmc) != HAL_MMC_CARD_TRANSFER)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT) - { - hmmc->ErrorCode = HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - return status; -} - -/** - * @brief Gets the current mmc card data state. - * @param hmmc: pointer to MMC handle - * @retval Card state - */ -HAL_MMC_CardStateTypeDef HAL_MMC_GetCardState(MMC_HandleTypeDef *hmmc) -{ - uint32_t cardstate; - uint32_t errorstate; - uint32_t resp1 = 0U; - - errorstate = MMC_SendStatus(hmmc, &resp1); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - - cardstate = ((resp1 >> 9U) & 0x0FU); - - return (HAL_MMC_CardStateTypeDef)cardstate; -} - -/** - * @brief Abort the current transfer and disable the MMC. - * @param hmmc: pointer to a MMC_HandleTypeDef structure that contains - * the configuration information for MMC module. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_Abort(MMC_HandleTypeDef *hmmc) -{ - uint32_t error_code; - uint32_t tickstart; - - if (hmmc->State == HAL_MMC_STATE_BUSY) - { - /* DIsable All interrupts */ - __HAL_MMC_DISABLE_IT(hmmc, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR); - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /*we will send the CMD12 in all cases in order to stop the data transfers*/ - /*In case the data transfer just finished, the external memory will not respond - and will return HAL_MMC_ERROR_CMD_RSP_TIMEOUT*/ - /*In case the data transfer aborted , the external memory will respond and will return HAL_MMC_ERROR_NONE*/ - /*Other scenario will return HAL_ERROR*/ - - hmmc->ErrorCode = SDMMC_CmdStopTransfer(hmmc->Instance); - error_code = hmmc->ErrorCode; - if ((error_code != HAL_MMC_ERROR_NONE) && (error_code != HAL_MMC_ERROR_CMD_RSP_TIMEOUT)) - { - return HAL_ERROR; - } - - tickstart = HAL_GetTick(); - if ((hmmc->Instance->DCTRL & SDMMC_DCTRL_DTDIR) == SDMMC_TRANSFER_DIR_TO_CARD) - { - if (hmmc->ErrorCode == HAL_MMC_ERROR_NONE) - { - while (!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DABORT | SDMMC_FLAG_BUSYD0END)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT) - { - hmmc->ErrorCode = HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - } - - if (hmmc->ErrorCode == HAL_MMC_ERROR_CMD_RSP_TIMEOUT) - { - while (!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DATAEND)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT) - { - hmmc->ErrorCode = HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - } - } - else if ((hmmc->Instance->DCTRL & SDMMC_DCTRL_DTDIR) == SDMMC_TRANSFER_DIR_TO_SDMMC) - { - while (!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DABORT | SDMMC_FLAG_DATAEND)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT) - { - hmmc->ErrorCode = HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - } - else - { - /* Nothing to do*/ - } - - /*The reason of all these while conditions previously is that we need to wait the SDMMC and clear - the appropriate flags that will be set depending of the abort/non abort of the memory */ - /*Not waiting the SDMMC flags will cause the next SDMMC_DISABLE_IDMA to not get cleared and will result - in next SDMMC read/write operation to fail */ - - /*SDMMC ready for clear data flags*/ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_BUSYD0END); - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - /* If IDMA Context, disable Internal DMA */ - hmmc->Instance->IDMACTRL = SDMMC_DISABLE_IDMA; - - hmmc->State = HAL_MMC_STATE_READY; - - /* Initialize the MMC operation */ - hmmc->Context = MMC_CONTEXT_NONE; - } - return HAL_OK; -} -/** - * @brief Abort the current transfer and disable the MMC (IT mode). - * @param hmmc: pointer to a MMC_HandleTypeDef structure that contains - * the configuration information for MMC module. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_Abort_IT(MMC_HandleTypeDef *hmmc) -{ - HAL_MMC_CardStateTypeDef CardState; - - /* DIsable All interrupts */ - __HAL_MMC_DISABLE_IT(hmmc, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR); - - /* If IDMA Context, disable Internal DMA */ - hmmc->Instance->IDMACTRL = SDMMC_DISABLE_IDMA; - - /* Clear All flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - CardState = HAL_MMC_GetCardState(hmmc); - hmmc->State = HAL_MMC_STATE_READY; - - if ((CardState == HAL_MMC_CARD_RECEIVING) || (CardState == HAL_MMC_CARD_SENDING)) - { - hmmc->ErrorCode = SDMMC_CmdStopTransfer(hmmc->Instance); - } - if (hmmc->ErrorCode != HAL_MMC_ERROR_NONE) - { - return HAL_ERROR; - } - else - { -#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U) - hmmc->AbortCpltCallback(hmmc); -#else - HAL_MMC_AbortCallback(hmmc); -#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */ - } - - return HAL_OK; -} - -/** - * @brief Perform specific commands sequence for the different type of erase. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @param hmmc Pointer to MMC handle - * @param EraseType Specifies the type of erase to be performed - * This parameter can be one of the following values: - * @arg HAL_MMC_TRIM Erase the write blocks identified by CMD35 & 36 - * @arg HAL_MMC_ERASE Erase the erase groups identified by CMD35 & 36 - * @arg HAL_MMC_DISCARD Discard the write blocks identified by CMD35 & 36 - * @arg HAL_MMC_SECURE_ERASE Perform a secure purge according SRT on the erase groups identified - * by CMD35 & 36 - * @arg HAL_MMC_SECURE_TRIM_STEP1 Mark the write blocks identified by CMD35 & 36 for secure erase - * @arg HAL_MMC_SECURE_TRIM_STEP2 Perform a secure purge according SRT on the write blocks - * previously identified - * @param BlockStartAdd Start Block address - * @param BlockEndAdd End Block address - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_EraseSequence(MMC_HandleTypeDef *hmmc, uint32_t EraseType, - uint32_t BlockStartAdd, uint32_t BlockEndAdd) -{ - uint32_t errorstate; - uint32_t start_add = BlockStartAdd; - uint32_t end_add = BlockEndAdd; - uint32_t tickstart = HAL_GetTick(); - - /* Check the erase type value is correct */ - assert_param(IS_MMC_ERASE_TYPE(EraseType)); - - /* Check the coherence between start and end address */ - if (end_add < start_add) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - /* Check that the end address is not out of range of device memory */ - if (end_add > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if (((start_add % 8U) != 0U) || ((end_add % 8U) != 0U)) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - /* Check if the card command class supports erase command */ - if (((hmmc->MmcCard.Class) & SDMMC_CCCC_ERASE) == 0U) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_REQUEST_NOT_APPLICABLE; - return HAL_ERROR; - } - - /* Check the state of the driver */ - if (hmmc->State == HAL_MMC_STATE_READY) - { - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Check that the card is not locked */ - if ((SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_LOCK_UNLOCK_FAILED; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* In case of low capacity card, the address is not block number but bytes */ - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - start_add *= MMC_BLOCKSIZE; - end_add *= MMC_BLOCKSIZE; - } - - /* Send CMD35 MMC_ERASE_GRP_START with start address as argument */ - errorstate = SDMMC_CmdEraseStartAdd(hmmc->Instance, start_add); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Send CMD36 MMC_ERASE_GRP_END with end address as argument */ - errorstate = SDMMC_CmdEraseEndAdd(hmmc->Instance, end_add); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Send CMD38 ERASE with erase type as argument */ - errorstate = SDMMC_CmdErase(hmmc->Instance, EraseType); - if (errorstate == HAL_MMC_ERROR_NONE) - { - if ((EraseType == HAL_MMC_SECURE_ERASE) || (EraseType == HAL_MMC_SECURE_TRIM_STEP2)) - { - /* Wait that the device is ready by checking the D0 line */ - while ((!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_BUSYD0END)) && (errorstate == HAL_MMC_ERROR_NONE)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_MAXERASETIMEOUT) - { - errorstate = HAL_MMC_ERROR_TIMEOUT; - } - } - - /* Clear the flag corresponding to end D0 bus line */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_BUSYD0END); - } - } - } - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - - /* Manage errors */ - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - - if (errorstate != HAL_MMC_ERROR_TIMEOUT) - { - return HAL_ERROR; - } - else - { - return HAL_TIMEOUT; - } - } - else - { - return HAL_OK; - } - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Perform sanitize operation on the device. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @param hmmc Pointer to MMC handle - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_Sanitize(MMC_HandleTypeDef *hmmc) -{ - uint32_t errorstate; - uint32_t response = 0U; - uint32_t count; - uint32_t tickstart = HAL_GetTick(); - - /* Check the state of the driver */ - if (hmmc->State == HAL_MMC_STATE_READY) - { - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Index : 165 - Value : 0x01 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03A50100U); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Wait that the device is ready by checking the D0 line */ - while ((!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_BUSYD0END)) && (errorstate == HAL_MMC_ERROR_NONE)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_MAXERASETIMEOUT) - { - errorstate = HAL_MMC_ERROR_TIMEOUT; - } - } - - /* Clear the flag corresponding to end D0 bus line */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_BUSYD0END); - - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE)) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } - } - else if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else - { - /* Nothing to do */ - } - } - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - - /* Manage errors */ - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - - if (errorstate != HAL_MMC_ERROR_TIMEOUT) - { - return HAL_ERROR; - } - else - { - return HAL_TIMEOUT; - } - } - else - { - return HAL_OK; - } - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Configure the Secure Removal Type (SRT) in the Extended CSD register. - * @note This API should be followed by a check on the card state through - * HAL_MMC_GetCardState(). - * @param hmmc Pointer to MMC handle - * @param SRTMode Specifies the type of erase to be performed - * This parameter can be one of the following values: - * @arg HAL_MMC_SRT_ERASE Information removed by an erase - * @arg HAL_MMC_SRT_WRITE_CHAR_ERASE Information removed by an overwriting with a character - * followed by an erase - * @arg HAL_MMC_SRT_WRITE_CHAR_COMPL_RANDOM Information removed by an overwriting with a character, - * its complement then a random character - * @arg HAL_MMC_SRT_VENDOR_DEFINED Information removed using a vendor defined - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_ConfigSecRemovalType(MMC_HandleTypeDef *hmmc, uint32_t SRTMode) -{ - uint32_t srt; - uint32_t errorstate; - uint32_t response = 0U; - uint32_t count; - - /* Check the erase type value is correct */ - assert_param(IS_MMC_SRT_TYPE(SRTMode)); - - /* Check the state of the driver */ - if (hmmc->State == HAL_MMC_STATE_READY) - { - /* Get the supported values by the device */ - if (HAL_MMC_GetSupportedSecRemovalType(hmmc, &srt) == HAL_OK) - { - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Check the value passed as parameter is supported by the device */ - if ((SRTMode & srt) != 0U) - { - /* Index : 16 - Value : SRTMode */ - srt |= ((POSITION_VAL(SRTMode)) << 4U); - errorstate = SDMMC_CmdSwitch(hmmc->Instance, (0x03100000U | (srt << 8U))); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE)) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } - } - else if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else - { - /* Nothing to do */ - } - } - } - else - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - } - else - { - errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } - - /* Manage errors */ - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - return HAL_ERROR; - } - else - { - return HAL_OK; - } - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Gets the supported values of the the Secure Removal Type (SRT). - * @param hmmc pointer to MMC handle - * @param SupportedSRT pointer for supported SRT value - * This parameter is a bit field of the following values: - * @arg HAL_MMC_SRT_ERASE Information removed by an erase - * @arg HAL_MMC_SRT_WRITE_CHAR_ERASE Information removed by an overwriting with a character followed - * by an erase - * @arg HAL_MMC_SRT_WRITE_CHAR_COMPL_RANDOM Information removed by an overwriting with a character, - * its complement then a random character - * @arg HAL_MMC_SRT_VENDOR_DEFINED Information removed using a vendor defined - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_GetSupportedSecRemovalType(MMC_HandleTypeDef *hmmc, uint32_t *SupportedSRT) -{ - /* Check the state of the driver */ - if (hmmc->State == HAL_MMC_STATE_READY) - { - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Read field SECURE_REMOVAL_TYPE [16 = 4*4] of the Extended CSD register */ - *SupportedSRT = (hmmc->Ext_CSD[4] & 0x0000000FU); /* Bits [3:0] of field 16 */ - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Switch the device from Standby State to Sleep State. - * @param hmmc pointer to MMC handle - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_SleepDevice(MMC_HandleTypeDef *hmmc) -{ - uint32_t errorstate, - sleep_timeout, - timeout, - count, - response = 0U ; - uint32_t tickstart = HAL_GetTick(); - - /* Check the state of the driver */ - if (hmmc->State == HAL_MMC_STATE_READY) - { - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Set the power-off notification to powered-on : Ext_CSD[34] = 1 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, (0x03220100U)); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - else - { - /* Set the power-off notification to sleep notification : Ext_CSD[34] = 4 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, (0x03220400U)); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Field SLEEP_NOTIFICATION_TIME [216] */ - sleep_timeout = ((hmmc->Ext_CSD[(MMC_EXT_CSD_SLEEP_NOTIFICATION_TIME_INDEX / 4)] >> - MMC_EXT_CSD_SLEEP_NOTIFICATION_TIME_POS) & 0x000000FFU); - - /* Sleep/Awake Timeout = 10us * 2^SLEEP_NOTIFICATION_TIME */ - /* In HAL, the tick interrupt occurs each ms */ - if ((sleep_timeout == 0U) || (sleep_timeout > 0x17U)) - { - sleep_timeout = 0x17U; /* Max register value defined is 0x17 */ - } - timeout = (((1UL << sleep_timeout) / 100U) + 1U); - - /* Wait that the device is ready by checking the D0 line */ - while ((!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_BUSYD0END)) && (errorstate == HAL_MMC_ERROR_NONE)) - { - if ((HAL_GetTick() - tickstart) >= timeout) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - } - - /* Clear the flag corresponding to end D0 bus line */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_BUSYD0END); - - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, - (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - else - { - /* Switch the device in stand-by mode */ - (void)SDMMC_CmdSelDesel(hmmc->Instance, 0U); - - /* Field S_A_TIEMOUT [217] */ - sleep_timeout = ((hmmc->Ext_CSD[(MMC_EXT_CSD_S_A_TIMEOUT_INDEX / 4)] >> - MMC_EXT_CSD_S_A_TIMEOUT_POS) & 0x000000FFU); - - /* Sleep/Awake Timeout = 100ns * 2^S_A_TIMEOUT */ - /* In HAL, the tick interrupt occurs each ms */ - if ((sleep_timeout == 0U) || (sleep_timeout > 0x17U)) - { - sleep_timeout = 0x17U; /* Max register value defined is 0x17 */ - } - timeout = (((1UL << sleep_timeout) / 10000U) + 1U); - - if (HAL_MMC_GetCardState(hmmc) == HAL_MMC_CARD_STANDBY) - { - /* Send CMD5 CMD_MMC_SLEEP_AWAKE with RCA and SLEEP as argument */ - errorstate = SDMMC_CmdSleepMmc(hmmc->Instance, - ((hmmc->MmcCard.RelCardAdd << 16U) | (0x1U << 15U))); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Wait that the device is ready by checking the D0 line */ - while ((!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_BUSYD0END)) && (errorstate == HAL_MMC_ERROR_NONE)) - { - if ((HAL_GetTick() - tickstart) >= timeout) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - } - - /* Clear the flag corresponding to end D0 bus line */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_BUSYD0END); - } - } - else - { - errorstate = SDMMC_ERROR_REQUEST_NOT_APPLICABLE; - } - } - } - else - { - /* Nothing to do */ - } - } - } - } - } - else - { - /* Nothing to do */ - } - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - - /* Manage errors */ - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - - if (errorstate != HAL_MMC_ERROR_TIMEOUT) - { - return HAL_ERROR; - } - else - { - return HAL_TIMEOUT; - } - } - else - { - return HAL_OK; - } - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Switch the device from Sleep State to Standby State. - * @param hmmc pointer to MMC handle - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_AwakeDevice(MMC_HandleTypeDef *hmmc) -{ - uint32_t errorstate; - uint32_t sleep_timeout; - uint32_t timeout; - uint32_t count; - uint32_t response = 0U; - uint32_t tickstart = HAL_GetTick(); - - /* Check the state of the driver */ - if (hmmc->State == HAL_MMC_STATE_READY) - { - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Field S_A_TIEMOUT [217] */ - sleep_timeout = ((hmmc->Ext_CSD[(MMC_EXT_CSD_S_A_TIMEOUT_INDEX / 4)] >> MMC_EXT_CSD_S_A_TIMEOUT_POS) & - 0x000000FFU); - - /* Sleep/Awake Timeout = 100ns * 2^S_A_TIMEOUT */ - /* In HAL, the tick interrupt occurs each ms */ - if ((sleep_timeout == 0U) || (sleep_timeout > 0x17U)) - { - sleep_timeout = 0x17U; /* Max register value defined is 0x17 */ - } - timeout = (((1UL << sleep_timeout) / 10000U) + 1U); - - /* Send CMD5 CMD_MMC_SLEEP_AWAKE with RCA and AWAKE as argument */ - errorstate = SDMMC_CmdSleepMmc(hmmc->Instance, (hmmc->MmcCard.RelCardAdd << 16U)); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Wait that the device is ready by checking the D0 line */ - while ((!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_BUSYD0END)) && (errorstate == HAL_MMC_ERROR_NONE)) - { - if ((HAL_GetTick() - tickstart) >= timeout) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - } - - /* Clear the flag corresponding to end D0 bus line */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_BUSYD0END); - - if (errorstate == HAL_MMC_ERROR_NONE) - { - if (HAL_MMC_GetCardState(hmmc) == HAL_MMC_CARD_STANDBY) - { - /* Switch the device in transfer mode */ - errorstate = SDMMC_CmdSelDesel(hmmc->Instance, (hmmc->MmcCard.RelCardAdd << 16U)); - if (errorstate == HAL_MMC_ERROR_NONE) - { - if (HAL_MMC_GetCardState(hmmc) == HAL_MMC_CARD_TRANSFER) - { - /* Set the power-off notification to powered-on : Ext_CSD[34] = 1 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, (0x03220100U)); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, - (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - } - else - { - /* NOthing to do */ - } - } - } - else - { - errorstate = SDMMC_ERROR_REQUEST_NOT_APPLICABLE; - } - } - } - else - { - errorstate = SDMMC_ERROR_REQUEST_NOT_APPLICABLE; - } - } - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - - /* Manage errors */ - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - - if (errorstate != HAL_MMC_ERROR_TIMEOUT) - { - return HAL_ERROR; - } - else - { - return HAL_TIMEOUT; - } - } - else - { - return HAL_OK; - } - } - else - { - return HAL_BUSY; - } -} -/** - * @} - */ - -/** - * @} - */ - -/* Private function ----------------------------------------------------------*/ -/** @addtogroup MMC_Private_Functions - * @{ - */ - -/** - * @brief Initializes the mmc card. - * @param hmmc: Pointer to MMC handle - * @retval MMC Card error state - */ -static uint32_t MMC_InitCard(MMC_HandleTypeDef *hmmc) -{ - HAL_MMC_CardCSDTypeDef CSD; - uint32_t errorstate; - uint16_t mmc_rca = 2U; - MMC_InitTypeDef Init; - - /* Check the power State */ - if (SDMMC_GetPowerState(hmmc->Instance) == 0U) - { - /* Power off */ - return HAL_MMC_ERROR_REQUEST_NOT_APPLICABLE; - } - - /* Send CMD2 ALL_SEND_CID */ - errorstate = SDMMC_CmdSendCID(hmmc->Instance); - if (errorstate != HAL_MMC_ERROR_NONE) - { - return errorstate; - } - else - { - /* Get Card identification number data */ - hmmc->CID[0U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - hmmc->CID[1U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP2); - hmmc->CID[2U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP3); - hmmc->CID[3U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP4); - } - - /* Send CMD3 SET_REL_ADDR with RCA = 2 (should be greater than 1) */ - /* MMC Card publishes its RCA. */ - errorstate = SDMMC_CmdSetRelAddMmc(hmmc->Instance, mmc_rca); - if (errorstate != HAL_MMC_ERROR_NONE) - { - return errorstate; - } - - /* Get the MMC card RCA */ - hmmc->MmcCard.RelCardAdd = mmc_rca; - - /* Send CMD9 SEND_CSD with argument as card's RCA */ - errorstate = SDMMC_CmdSendCSD(hmmc->Instance, (uint32_t)(hmmc->MmcCard.RelCardAdd << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - return errorstate; - } - else - { - /* Get Card Specific Data */ - hmmc->CSD[0U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - hmmc->CSD[1U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP2); - hmmc->CSD[2U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP3); - hmmc->CSD[3U] = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP4); - } - - /* Get the Card Class */ - hmmc->MmcCard.Class = (SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP2) >> 20U); - - /* Select the Card */ - errorstate = SDMMC_CmdSelDesel(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - return errorstate; - } - - /* Get CSD parameters */ - if (HAL_MMC_GetCardCSD(hmmc, &CSD) != HAL_OK) - { - return hmmc->ErrorCode; - } - - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - - /* Get Extended CSD parameters */ - if (HAL_MMC_GetCardExtCSD(hmmc, hmmc->Ext_CSD, SDMMC_DATATIMEOUT) != HAL_OK) - { - return hmmc->ErrorCode; - } - - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - - /* Configure the SDMMC peripheral */ - Init = hmmc->Init; - Init.BusWide = SDMMC_BUS_WIDE_1B; - (void)SDMMC_Init(hmmc->Instance, Init); - - /* All cards are initialized */ - return HAL_MMC_ERROR_NONE; -} - -/** - * @brief Enquires cards about their operating voltage and configures clock - * controls and stores MMC information that will be needed in future - * in the MMC handle. - * @param hmmc: Pointer to MMC handle - * @retval error state - */ -static uint32_t MMC_PowerON(MMC_HandleTypeDef *hmmc) -{ - __IO uint32_t count = 0U; - uint32_t response = 0U; - uint32_t validvoltage = 0U; - uint32_t errorstate; - - /* CMD0: GO_IDLE_STATE */ - errorstate = SDMMC_CmdGoIdleState(hmmc->Instance); - if (errorstate != HAL_MMC_ERROR_NONE) - { - return errorstate; - } - - while (validvoltage == 0U) - { - if (count++ == SDMMC_MAX_VOLT_TRIAL) - { - return HAL_MMC_ERROR_INVALID_VOLTRANGE; - } - - /* SEND CMD1 APP_CMD with voltage range as argument */ - errorstate = SDMMC_CmdOpCondition(hmmc->Instance, MMC_VOLTAGE_RANGE); - if (errorstate != HAL_MMC_ERROR_NONE) - { - return HAL_MMC_ERROR_UNSUPPORTED_FEATURE; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - - /* Get operating voltage*/ - validvoltage = (((response >> 31U) == 1U) ? 1U : 0U); - } - - /* When power routine is finished and command returns valid voltage */ - if (((response & (0xFF000000U)) >> 24) == 0xC0U) - { - hmmc->MmcCard.CardType = MMC_HIGH_CAPACITY_CARD; - } - else - { - hmmc->MmcCard.CardType = MMC_LOW_CAPACITY_CARD; - } - - return HAL_MMC_ERROR_NONE; -} - -/** - * @brief Turns the SDMMC output signals off. - * @param hmmc: Pointer to MMC handle - * @retval None - */ -static void MMC_PowerOFF(MMC_HandleTypeDef *hmmc) -{ - /* Set Power State to OFF */ - (void)SDMMC_PowerState_OFF(hmmc->Instance); -} - -/** - * @brief Returns the current card's status. - * @param hmmc: Pointer to MMC handle - * @param pCardStatus: pointer to the buffer that will contain the MMC card - * status (Card Status register) - * @retval error state - */ -static uint32_t MMC_SendStatus(MMC_HandleTypeDef *hmmc, uint32_t *pCardStatus) -{ - uint32_t errorstate; - - if (pCardStatus == NULL) - { - return HAL_MMC_ERROR_PARAM; - } - - /* Send Status command */ - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(hmmc->MmcCard.RelCardAdd << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - return errorstate; - } - - /* Get MMC card status */ - *pCardStatus = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - - return HAL_MMC_ERROR_NONE; -} - -/** - * @brief Reads extended CSD register to get the sectors number of the device - * @param hmmc: Pointer to MMC handle - * @param pFieldData: Pointer to the read buffer - * @param FieldIndex: Index of the field to be read - * @param Timeout: Specify timeout value - * @retval HAL status - */ -static HAL_StatusTypeDef MMC_ReadExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pFieldData, - uint16_t FieldIndex, uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t i = 0; - uint32_t tmp_data; - - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0; - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_ENABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - - /* Set Block Size for Card */ - errorstate = SDMMC_CmdSendEXTCSD(hmmc->Instance, 0); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Poll on SDMMC flags */ - while (!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | - SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - tmp_data = SDMMC_ReadFIFO(hmmc->Instance); - /* eg : SEC_COUNT : FieldIndex = 212 => i+count = 53 */ - /* DEVICE_TYPE : FieldIndex = 196 => i+count = 49 */ - if ((i + count) == ((uint32_t)FieldIndex / 4U)) - { - *pFieldData = tmp_data; - } - } - i += 8U; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXOVERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->ErrorCode |= errorstate; - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - return HAL_OK; -} - -/** - * @brief Wrap up reading in non-blocking mode. - * @param hmmc: pointer to a MMC_HandleTypeDef structure that contains - * the configuration information. - * @retval None - */ -static void MMC_Read_IT(MMC_HandleTypeDef *hmmc) -{ - uint32_t count; - uint32_t data; - uint8_t *tmp; - - tmp = hmmc->pRxBuffPtr; - - if (hmmc->RxXferSize >= SDMMC_FIFO_SIZE) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hmmc->Instance); - *tmp = (uint8_t)(data & 0xFFU); - tmp++; - *tmp = (uint8_t)((data >> 8U) & 0xFFU); - tmp++; - *tmp = (uint8_t)((data >> 16U) & 0xFFU); - tmp++; - *tmp = (uint8_t)((data >> 24U) & 0xFFU); - tmp++; - } - - hmmc->pRxBuffPtr = tmp; - hmmc->RxXferSize -= SDMMC_FIFO_SIZE; - } -} - -/** - * @brief Wrap up writing in non-blocking mode. - * @param hmmc: pointer to a MMC_HandleTypeDef structure that contains - * the configuration information. - * @retval None - */ -static void MMC_Write_IT(MMC_HandleTypeDef *hmmc) -{ - uint32_t count; - uint32_t data; - const uint8_t *tmp; - - tmp = hmmc->pTxBuffPtr; - - if (hmmc->TxXferSize >= SDMMC_FIFO_SIZE) - { - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*tmp); - tmp++; - data |= ((uint32_t)(*tmp) << 8U); - tmp++; - data |= ((uint32_t)(*tmp) << 16U); - tmp++; - data |= ((uint32_t)(*tmp) << 24U); - tmp++; - (void)SDMMC_WriteFIFO(hmmc->Instance, &data); - } - - hmmc->pTxBuffPtr = tmp; - hmmc->TxXferSize -= SDMMC_FIFO_SIZE; - } -} - -/** - * @brief Switches the MMC card to high speed mode. - * @param hmmc: MMC handle - * @param state: State of high speed mode - * @retval MMC Card error state - */ -static uint32_t MMC_HighSpeed(MMC_HandleTypeDef *hmmc, FunctionalState state) -{ - uint32_t errorstate = HAL_MMC_ERROR_NONE; - uint32_t response = 0U; - uint32_t count; - uint32_t sdmmc_clk; - SDMMC_InitTypeDef Init; - - if (((hmmc->Instance->CLKCR & SDMMC_CLKCR_BUSSPEED) != 0U) && (state == DISABLE)) - { - errorstate = MMC_PwrClassUpdate(hmmc, (hmmc->Instance->CLKCR & SDMMC_CLKCR_WIDBUS), SDMMC_SPEED_MODE_DEFAULT); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Index : 185 - Value : 0 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B90000U); - } - } - - if (((hmmc->Instance->CLKCR & SDMMC_CLKCR_BUSSPEED) == 0U) && (state != DISABLE)) - { - errorstate = MMC_PwrClassUpdate(hmmc, (hmmc->Instance->CLKCR & SDMMC_CLKCR_WIDBUS), SDMMC_SPEED_MODE_HIGH); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Index : 185 - Value : 1 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B90100U); - } - } - - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE)) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - else - { - /* Configure high speed */ - Init.ClockEdge = hmmc->Init.ClockEdge; - Init.ClockPowerSave = hmmc->Init.ClockPowerSave; - Init.BusWide = (hmmc->Instance->CLKCR & SDMMC_CLKCR_WIDBUS); - Init.HardwareFlowControl = hmmc->Init.HardwareFlowControl; - - if (state == DISABLE) - { - Init.ClockDiv = hmmc->Init.ClockDiv; - (void)SDMMC_Init(hmmc->Instance, Init); - - CLEAR_BIT(hmmc->Instance->CLKCR, SDMMC_CLKCR_BUSSPEED); - } - else - { - /* High Speed Clock should be less or equal to 52MHz*/ - sdmmc_clk = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SDMMC); - - if (sdmmc_clk == 0U) - { - errorstate = SDMMC_ERROR_INVALID_PARAMETER; - } - else - { - if (sdmmc_clk <= MMC_HIGH_SPEED_FREQ) - { - Init.ClockDiv = 0; - } - else - { - Init.ClockDiv = (sdmmc_clk / (2U * MMC_HIGH_SPEED_FREQ)) + 1U; - } - (void)SDMMC_Init(hmmc->Instance, Init); - - SET_BIT(hmmc->Instance->CLKCR, SDMMC_CLKCR_BUSSPEED); - } - } - } - } - else if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else - { - /* Nothing to do */ - } - } - - return errorstate; -} - -/** - * @brief Switches the MMC card to Double Data Rate (DDR) mode. - * @param hmmc: MMC handle - * @param state: State of DDR mode - * @retval MMC Card error state - */ -static uint32_t MMC_DDR_Mode(MMC_HandleTypeDef *hmmc, FunctionalState state) -{ - uint32_t errorstate = HAL_MMC_ERROR_NONE; - uint32_t response = 0U; - uint32_t count; - - if (((hmmc->Instance->CLKCR & SDMMC_CLKCR_DDR) != 0U) && (state == DISABLE)) - { - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_WIDBUS_0) != 0U) - { - errorstate = MMC_PwrClassUpdate(hmmc, SDMMC_BUS_WIDE_4B, SDMMC_SPEED_MODE_HIGH); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Index : 183 - Value : 1 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70100U); - } - } - else - { - errorstate = MMC_PwrClassUpdate(hmmc, SDMMC_BUS_WIDE_8B, SDMMC_SPEED_MODE_HIGH); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Index : 183 - Value : 2 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70200U); - } - } - } - - if (((hmmc->Instance->CLKCR & SDMMC_CLKCR_DDR) == 0U) && (state != DISABLE)) - { - if ((hmmc->Instance->CLKCR & SDMMC_CLKCR_WIDBUS_0) != 0U) - { - errorstate = MMC_PwrClassUpdate(hmmc, SDMMC_BUS_WIDE_4B, SDMMC_SPEED_MODE_DDR); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Index : 183 - Value : 5 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70500U); - } - } - else - { - errorstate = MMC_PwrClassUpdate(hmmc, SDMMC_BUS_WIDE_8B, SDMMC_SPEED_MODE_DDR); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Index : 183 - Value : 6 */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70600U); - } - } - } - - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE)) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - else - { - /* Configure DDR mode */ - if (state == DISABLE) - { - CLEAR_BIT(hmmc->Instance->CLKCR, SDMMC_CLKCR_DDR); - } - else - { - SET_BIT(hmmc->Instance->CLKCR, SDMMC_CLKCR_DDR); - } - } - } - else if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else - { - /* Nothing to do */ - } - } - - return errorstate; -} - -/** - * @brief Update the power class of the device. - * @param hmmc MMC handle - * @param Wide Wide of MMC bus - * @param Speed Speed of the MMC bus - * @retval MMC Card error state - */ -static uint32_t MMC_PwrClassUpdate(MMC_HandleTypeDef *hmmc, uint32_t Wide, uint32_t Speed) -{ - uint32_t count; - uint32_t response = 0U; - uint32_t errorstate = HAL_MMC_ERROR_NONE; - uint32_t power_class; - uint32_t supported_pwr_class; - - if ((Wide == SDMMC_BUS_WIDE_8B) || (Wide == SDMMC_BUS_WIDE_4B)) - { - power_class = 0U; /* Default value after power-on or software reset */ - - /* Read the PowerClass field of the Extended CSD register */ - if (MMC_ReadExtCSD(hmmc, &power_class, 187, SDMMC_DATATIMEOUT) != HAL_OK) /* Field POWER_CLASS [187] */ - { - errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } - else - { - power_class = ((power_class >> 24U) & 0x000000FFU); - } - - /* Get the supported PowerClass field of the Extended CSD register */ - if (Speed == SDMMC_SPEED_MODE_DDR) - { - /* Field PWR_CL_DDR_52_xxx [238 or 239] */ - supported_pwr_class = ((hmmc->Ext_CSD[(MMC_EXT_CSD_PWR_CL_DDR_52_INDEX / 4)] >> MMC_EXT_CSD_PWR_CL_DDR_52_POS) & - 0x000000FFU); - } - else if (Speed == SDMMC_SPEED_MODE_HIGH) - { - /* Field PWR_CL_52_xxx [200 or 202] */ - supported_pwr_class = ((hmmc->Ext_CSD[(MMC_EXT_CSD_PWR_CL_52_INDEX / 4)] >> MMC_EXT_CSD_PWR_CL_52_POS) & - 0x000000FFU); - } - else - { - /* Field PWR_CL_26_xxx [201 or 203] */ - supported_pwr_class = ((hmmc->Ext_CSD[(MMC_EXT_CSD_PWR_CL_26_INDEX / 4)] >> MMC_EXT_CSD_PWR_CL_26_POS) & - 0x000000FFU); - } - - if (errorstate == HAL_MMC_ERROR_NONE) - { - if (Wide == SDMMC_BUS_WIDE_8B) - { - /* Bit [7:4]: power class for 8-bits bus configuration - Bit [3:0]: power class for 4-bits bus configuration */ - supported_pwr_class = (supported_pwr_class >> 4U); - } - - if ((power_class & 0x0FU) != (supported_pwr_class & 0x0FU)) - { - /* Need to change current power class */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, (0x03BB0000U | ((supported_pwr_class & 0x0FU) << 8U))); - - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE)) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - } - else if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else - { - /* Nothing to do */ - } - } - } - } - } - - return errorstate; -} - -/** - * @brief Used to select the partition. - * @param hmmc: Pointer to MMC handle - * @param Partition: Partition type - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_SwitchPartition(MMC_HandleTypeDef *hmmc, HAL_MMC_PartitionTypeDef Partition) -{ - uint32_t errorstate; - uint32_t response = 0U; - uint32_t count; - uint32_t tickstart = HAL_GetTick(); - uint32_t arg = Partition | 0x03B30000U; - - /* Check the state of the driver */ - if (hmmc->State == HAL_MMC_STATE_READY) - { - /* Change State */ - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Index : 179 - Value : partition */ - errorstate = SDMMC_CmdSwitch(hmmc->Instance, arg); - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* Wait that the device is ready by checking the D0 line */ - while ((!__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_BUSYD0END)) && (errorstate == HAL_MMC_ERROR_NONE)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_MAXERASETIMEOUT) - { - errorstate = HAL_MMC_ERROR_TIMEOUT; - } - } - - /* Clear the flag corresponding to end D0 bus line */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_FLAG_BUSYD0END); - - if (errorstate == HAL_MMC_ERROR_NONE) - { - /* While card is not ready for data and trial number for sending CMD13 is not exceeded */ - count = SDMMC_MAX_TRIAL; - do - { - errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U)); - if (errorstate != HAL_MMC_ERROR_NONE) - { - break; - } - - /* Get command response */ - response = SDMMC_GetResponse(hmmc->Instance, SDMMC_RESP1); - count--; - } while (((response & 0x100U) == 0U) && (count != 0U)); - - /* Check the status after the switch command execution */ - if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE)) - { - /* Check the bit SWITCH_ERROR of the device status */ - if ((response & 0x80U) != 0U) - { - errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } - } - else if (count == 0U) - { - errorstate = SDMMC_ERROR_TIMEOUT; - } - else - { - /* Nothing to do */ - } - } - } - - /* Change State */ - hmmc->State = HAL_MMC_STATE_READY; - - /* Manage errors */ - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - - if (errorstate != HAL_MMC_ERROR_TIMEOUT) - { - return HAL_ERROR; - } - else - { - return HAL_TIMEOUT; - } - } - else - { - return HAL_OK; - } - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Allows to program the authentication key within the RPMB partition - * @param hmmc: Pointer to MMC handle - * @param pKey: pointer to the authentication key (32 bytes) - * @param Timeout: Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_RPMB_ProgramAuthenticationKey(MMC_HandleTypeDef *hmmc, const uint8_t *pKey, uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t byte_count = 0; - uint32_t data; - uint32_t dataremaining; - uint8_t tail_pack[12] = {0}; - uint8_t zero_pack[4] = {0}; - const uint8_t *rtempbuff; - uint8_t *tempbuff; - - tail_pack[11] = 0x01; - - if (NULL == pKey) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, 0x80000001U); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - { - hmmc->Context = MMC_CONTEXT_WRITE_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, 0); - } - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Write block(s) in polling mode */ - rtempbuff = zero_pack; - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*rtempbuff); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 8U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 16U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 24U); - rtempbuff++; - byte_count++; - (void)SDMMC_WriteFIFO(hmmc->Instance, &data); - if (byte_count < MMC_RPMB_KEYMAC_POSITION) - { - rtempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_KEYMAC_POSITION) - { - rtempbuff = pKey; - } - else if ((byte_count < MMC_RPMB_WRITE_COUNTER_POSITION) && \ - (byte_count >= MMC_RPMB_DATA_POSITION)) - { - rtempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - rtempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Read Response Packet */ - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, 0x00000001); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, 0); - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - /* Poll on SDMMC flags */ - tempbuff = zero_pack; - byte_count = 0; - - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hmmc->Instance); - *tempbuff = (uint8_t)(data & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 8U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 16U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 24U) & 0xFFU); - tempbuff++; - byte_count++; - if (byte_count < MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXUNDERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - /* Check result of operation */ - if ((tail_pack[9] != 0x00U) || (tail_pack[10] != 0x01U)) - { - hmmc->RPMBErrorCode |= tail_pack[9]; - return HAL_ERROR; - } - - return HAL_OK; - } - else - { - hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY; - return HAL_ERROR; - } -} - -/** - * @brief Allows to get the value of write counter within the RPMB partition. - * @param hmmc: Pointer to MMC handle - * @param pNonce: pointer to the value of nonce (16 bytes) - * @param Timeout: Specify timeout value - * @retval write counter value. - */ -uint32_t HAL_MMC_RPMB_GetWriteCounter(MMC_HandleTypeDef *hmmc, uint8_t *pNonce, uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t byte_count = 0; - uint32_t data; - uint32_t dataremaining; - uint8_t tail_pack[12] = {0}; - uint8_t zero_pack[4] = {0}; - uint8_t echo_nonce[16] = {0}; - uint8_t *tempbuff = zero_pack; - - tail_pack[11] = 0x02; - - if (NULL == pNonce) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, 0x00000001U); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - - /* Send Request Packet */ - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - hmmc->Context = MMC_CONTEXT_WRITE_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, 0); - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - - /* Write block(s) in polling mode */ - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*tempbuff); - tempbuff++; - byte_count++; - data |= ((uint32_t)(*tempbuff) << 8U); - tempbuff++; - byte_count++; - data |= ((uint32_t)(*tempbuff) << 16U); - tempbuff++; - byte_count++; - data |= ((uint32_t)(*tempbuff) << 24U); - tempbuff++; - byte_count++; - (void)SDMMC_WriteFIFO(hmmc->Instance, &data); - if (byte_count < MMC_RPMB_NONCE_POSITION) - { - tempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_NONCE_POSITION) - { - tempbuff = (uint8_t *)pNonce; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Read Response Packt */ - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, 0x00000001U); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, 0); - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - /* Poll on SDMMC flags */ - tempbuff = zero_pack; - - byte_count = 0; - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hmmc->Instance); - *tempbuff = (uint8_t)(data & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 8U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 16U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 24U) & 0xFFU); - tempbuff++; - byte_count++; - if (byte_count < MMC_RPMB_NONCE_POSITION) - { - tempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_NONCE_POSITION) - { - tempbuff = echo_nonce; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXUNDERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN; - hmmc->State = HAL_MMC_STATE_READY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - for (uint8_t i = 0; i < 16U; i++) - { - if (pNonce[i] != echo_nonce[i]) - { - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } - } - - return ((uint32_t)tail_pack[3] | ((uint32_t)tail_pack[2] << 8) | ((uint32_t)tail_pack[1] << 16) | \ - ((uint32_t)tail_pack[0] << 24)); - } - else - { - hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY; - hmmc->RPMBErrorCode |= HAL_MMC_ERROR_RPMB_COUNTER_FAILURE; - return 0; - } -} - -/** - * @brief Allows to write block(s) to a specified address in the RPMB partition. The Data - * transfer is managed by polling mode. - * @param hmmc: Pointer to MMC handle - * @param pData: Pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of blocks to write - * @param pMAC: Pointer to the authentication MAC buffer - * @param Timeout: Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_RPMB_WriteBlocks(MMC_HandleTypeDef *hmmc, const uint8_t *pData, uint16_t BlockAdd, - uint16_t NumberOfBlocks, const uint8_t *pMAC, uint32_t Timeout) -{ - - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t byte_count = 0; - uint32_t data; - uint32_t dataremaining; - uint8_t tail_pack[12] = {0}; - uint8_t zero_pack[4] = {0}; - uint8_t echo_nonce[16] = {0}; - const uint8_t local_nonce[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x00, 0x01, 0x02, - 0x03, 0x04, 0x00, 0x01, 0x02, 0x03, 0x04, 0x08 - }; - const uint8_t *rtempbuff; - uint8_t *tempbuff; - uint32_t arg = 0x80000000U; - uint32_t offset = 0; - - if ((NumberOfBlocks != 0x1U) && (NumberOfBlocks != 0x2U) && (NumberOfBlocks != 0x20U)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - if ((NULL == pData) || (NULL == pMAC)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM; - return HAL_ERROR; - } - - tail_pack[11] = 0x02; - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, 0x00000001U); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Send Request Packet */ - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - hmmc->Context = MMC_CONTEXT_WRITE_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, 0); - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Write block(s) in polling mode */ - rtempbuff = zero_pack; - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*rtempbuff); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 8U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 16U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 24U); - rtempbuff++; - byte_count++; - (void)SDMMC_WriteFIFO(hmmc->Instance, &data); - if (byte_count < MMC_RPMB_NONCE_POSITION) - { - rtempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_NONCE_POSITION) - { - rtempbuff = local_nonce; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - rtempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Read Response Packt */ - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, 0x00000001); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, 0); - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - /* Poll on SDMMC flags */ - tempbuff = zero_pack; - - byte_count = 0; - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hmmc->Instance); - *tempbuff = (uint8_t)(data & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 8U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 16U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 24U) & 0xFFU); - tempbuff++; - byte_count++; - if (byte_count < MMC_RPMB_NONCE_POSITION) - { - tempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_NONCE_POSITION) - { - tempbuff = echo_nonce; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXUNDERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - for (uint8_t i = 0; i < 16U; i++) - { - if (local_nonce[i] != echo_nonce[i]) - { - return HAL_ERROR; - } - } - } - else - { - hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY; - return HAL_ERROR; - } - tail_pack[11] = 0x03; - tail_pack[10] = 0x00; - tail_pack[7] = (uint8_t)(NumberOfBlocks) & 0xFFU; - tail_pack[6] = (uint8_t)(NumberOfBlocks >> 8) & 0xFFU; - tail_pack[5] = (uint8_t)(BlockAdd) & 0xFFU; - tail_pack[4] = (uint8_t)(BlockAdd >> 8) & 0xFFU; - - rtempbuff = zero_pack; - byte_count = 0; - arg |= NumberOfBlocks; - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, arg); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Send Request Packet */ - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = NumberOfBlocks * MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - - { - hmmc->Context = MMC_CONTEXT_WRITE_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, 0); - } - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - - /* Write block(s) in polling mode */ - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*rtempbuff); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 8U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 16U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 24U); - rtempbuff++; - byte_count++; - (void)SDMMC_WriteFIFO(hmmc->Instance, &data); - if (byte_count == MMC_RPMB_KEYMAC_POSITION) - { - rtempbuff = pMAC; - } - if (byte_count == MMC_RPMB_DATA_POSITION) - { - rtempbuff = &pData[offset]; - } - if ((byte_count >= MMC_RPMB_NONCE_POSITION) && \ - (byte_count < MMC_RPMB_WRITE_COUNTER_POSITION)) - { - rtempbuff = zero_pack; - } - if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - rtempbuff = tail_pack; - } - else if (byte_count == MMC_BLOCKSIZE) - { - offset += (uint32_t)256U; - byte_count = 0; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Response Packet */ - - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, arg); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - - { - hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, 0); - } - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - /* Poll on SDMMC flags */ - tempbuff = zero_pack; - byte_count = 0; - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hmmc->Instance); - *tempbuff = (uint8_t)(data & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 8U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 16U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 24U) & 0xFFU); - tempbuff++; - byte_count++; - if (byte_count < MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXUNDERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - /* Check result of operation */ - if (((tail_pack[9] & (uint8_t)0xFEU) != 0x00U) || (tail_pack[10] != 0x03U)) - { - hmmc->RPMBErrorCode |= tail_pack[9]; - return HAL_ERROR; - } - - return HAL_OK; - } - else - { - hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY; - return HAL_ERROR; - } -} - -/** - * @brief Allows to read block(s) to a specified address in the RPMB partition. The Data - * transfer is managed by polling mode. - * @param hmmc: Pointer to MMC handle - * @param pData: Pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of blocks to write - * @param pNonce: Pointer to the buffer that will contain the nonce to transmit - * @param pMAC: Pointer to the authentication MAC buffer - * @param Timeout: Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMC_RPMB_ReadBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint16_t BlockAdd, - uint16_t NumberOfBlocks, const uint8_t *pNonce, uint8_t *pMAC, - uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t byte_count = 0; - uint32_t data; - uint8_t tail_pack[12] = {0}; - uint8_t zero_pack[4] = {0}; - uint8_t echo_nonce[16] = {0}; - uint32_t dataremaining; - const uint8_t *rtempbuff; - uint8_t *tempbuff; - uint32_t arg = 0; - uint32_t offset = 0; - - arg |= NumberOfBlocks; - - tail_pack[11] = 0x04; - tail_pack[10] = 0x00; - tail_pack[7] = 0x00; - tail_pack[6] = 0x00; - tail_pack[5] = (uint8_t)(BlockAdd) & 0xFFU; - tail_pack[4] = (uint8_t)(BlockAdd >> 8) & 0xFFU; - tail_pack[3] = 0x00; - tail_pack[2] = 0x00; - tail_pack[1] = 0x00; - tail_pack[0] = 0x00; - - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - hmmc->State = HAL_MMC_STATE_BUSY; - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0U; - - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, 1); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Send Request Packet */ - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - hmmc->Context = MMC_CONTEXT_WRITE_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, 0); - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Write block(s) in polling mode */ - rtempbuff = zero_pack; - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*rtempbuff); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 8U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 16U); - rtempbuff++; - byte_count++; - data |= ((uint32_t)(*rtempbuff) << 24U); - rtempbuff++; - byte_count++; - (void)SDMMC_WriteFIFO(hmmc->Instance, &data); - if (byte_count < MMC_RPMB_NONCE_POSITION) - { - rtempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_NONCE_POSITION) - { - rtempbuff = pNonce; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - rtempbuff = tail_pack; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Read Response Packet */ - errorstate = SDMMC_CmdBlockCount(hmmc->Instance, arg); - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = NumberOfBlocks * MMC_BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - /* Write Blocks in Polling mode */ - hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, 0); - - if (errorstate != HAL_MMC_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= errorstate; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - /* Poll on SDMMC flags */ - tempbuff = zero_pack; - byte_count = 0; - - dataremaining = config.DataLength; - while (!__HAL_MMC_GET_FLAG(hmmc, - SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hmmc->Instance); - *tempbuff = (uint8_t)(data & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 8U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 16U) & 0xFFU); - tempbuff++; - byte_count++; - *tempbuff = (uint8_t)((data >> 24U) & 0xFFU); - tempbuff++; - byte_count++; - if (byte_count < MMC_RPMB_KEYMAC_POSITION) - { - tempbuff = zero_pack; - } - else if (byte_count == MMC_RPMB_KEYMAC_POSITION) - { - tempbuff = (uint8_t *)pMAC; - } - else if (byte_count == MMC_RPMB_DATA_POSITION) - { - tempbuff = &pData[offset]; - } - else if (byte_count == MMC_RPMB_NONCE_POSITION) - { - tempbuff = echo_nonce; - } - else if (byte_count == MMC_RPMB_WRITE_COUNTER_POSITION) - { - tempbuff = tail_pack; - } - else if (byte_count == MMC_BLOCKSIZE) - { - byte_count = 0; - offset += (uint32_t)256U; - } - else - { - /* Nothing to do */ - } - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hmmc->Instance); - - /* Get error state */ - if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else if (__HAL_MMC_GET_FLAG(hmmc, SDMMC_FLAG_TXUNDERR)) - { - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS); - hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN; - hmmc->State = HAL_MMC_STATE_READY; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_DATA_FLAGS); - - hmmc->State = HAL_MMC_STATE_READY; - - for (uint8_t i = 0; i < 16U; i++) - { - if (pNonce[i] != echo_nonce[i]) - { - return HAL_ERROR; - } - } - - /* Check result of operation */ - if ((tail_pack[9] != 0x00U) || (tail_pack[10] != 0x04U)) - { - hmmc->RPMBErrorCode |= tail_pack[9]; - return HAL_ERROR; - } - - return HAL_OK; - } - else - { - hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY; - return HAL_ERROR; - } -} - - -/** - * @brief Read DMA Buffer 0 Transfer completed callbacks - * @param hmmc: MMC handle - * @retval None - */ -__weak void HAL_MMCEx_Read_DMADoubleBuf0CpltCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMCEx_Read_DMADoubleBuf0CpltCallback can be implemented in the user file - */ -} - -/** - * @brief Read DMA Buffer 1 Transfer completed callbacks - * @param hmmc: MMC handle - * @retval None - */ -__weak void HAL_MMCEx_Read_DMADoubleBuf1CpltCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMCEx_Read_DMADoubleBuf1CpltCallback can be implemented in the user file - */ -} - -/** - * @brief Write DMA Buffer 0 Transfer completed callbacks - * @param hmmc: MMC handle - * @retval None - */ -__weak void HAL_MMCEx_Write_DMADoubleBuf0CpltCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMCEx_Write_DMADoubleBuf0CpltCallback can be implemented in the user file - */ -} - -/** - * @brief Write DMA Buffer 1 Transfer completed callbacks - * @param hmmc: MMC handle - * @retval None - */ -__weak void HAL_MMCEx_Write_DMADoubleBuf1CpltCallback(MMC_HandleTypeDef *hmmc) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hmmc); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_MMCEx_Write_DMADoubleBuf1CpltCallback can be implemented in the user file - */ -} - -/** - * @} - */ - -#endif /* HAL_MMC_MODULE_ENABLED */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ - -/** - * @} - */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c b/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c deleted file mode 100644 index 8723867..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c +++ /dev/null @@ -1,353 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_mmc_ex.c - * @author MCD Application Team - * @brief MMC card Extended HAL module driver. - * This file provides firmware functions to manage the following - * functionalities of the Secure Digital (MMC) peripheral: - * + Extended features functions - * - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - @verbatim - ============================================================================== - ##### How to use this driver ##### - ============================================================================== - [..] - The MMC Extension HAL driver can be used as follows: - (+) Configure Buffer0 and Buffer1 start address and Buffer size using HAL_MMCEx_ConfigDMAMultiBuffer() function. - - (+) Start Read and Write for multibuffer mode using HAL_MMCEx_ReadBlocksDMAMultiBuffer() and - HAL_MMCEx_WriteBlocksDMAMultiBuffer() functions. - - @endverbatim - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ - -/** @defgroup MMCEx MMCEx - * @brief MMC Extended HAL module driver - * @{ - */ - -#if defined (SDMMC1) || defined (SDMMC2) -#ifdef HAL_MMC_MODULE_ENABLED - -/* Private typedef -----------------------------------------------------------*/ -/* Private define ------------------------------------------------------------*/ -/* Private macro -------------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -/* Private function prototypes -----------------------------------------------*/ -/* Private functions ---------------------------------------------------------*/ -/* Exported functions --------------------------------------------------------*/ -/** @addtogroup MMCEx_Exported_Functions - * @{ - */ - - -/** @addtogroup MMCEx_Exported_Functions_Group1 - * @brief Multibuffer functions - * -@verbatim - ============================================================================== - ##### Multibuffer functions ##### - ============================================================================== - [..] - This section provides functions allowing to configure the multibuffer mode and start read and write - multibuffer mode for MMC HAL driver. - -@endverbatim - * @{ - */ - -/** - * @brief Configure DMA Dual Buffer mode. The Data transfer is managed by an Internal DMA. - * @param hmmc: MMC handle - * @param pDataBuffer0: Pointer to the buffer0 that will contain/receive the transferred data - * @param pDataBuffer1: Pointer to the buffer1 that will contain/receive the transferred data - * @param BufferSize: Size of Buffer0 in Blocks. Buffer0 and Buffer1 must have the same size. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMCEx_ConfigDMAMultiBuffer(MMC_HandleTypeDef *hmmc, uint32_t *pDataBuffer0, - uint32_t *pDataBuffer1, uint32_t BufferSize) -{ - if (hmmc->State == HAL_MMC_STATE_READY) - { - hmmc->Instance->IDMABASE0 = (uint32_t) pDataBuffer0 ; - hmmc->Instance->IDMABASE1 = (uint32_t) pDataBuffer1 ; - hmmc->Instance->IDMABSIZE = (uint32_t)(MMC_BLOCKSIZE * BufferSize); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Reads block(s) from a specified address in a card. The received Data will be stored in Buffer0 and Buffer1. - * Buffer0, Buffer1 and BufferSize need to be configured by function HAL_MMCEx_ConfigDMAMultiBuffer before - * call this function. - * @param hmmc: MMC handle - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Total number of blocks to read - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMCEx_ReadBlocksDMAMultiBuffer(MMC_HandleTypeDef *hmmc, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t DmaBase0_reg; - uint32_t DmaBase1_reg; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (hmmc->State == HAL_MMC_STATE_READY) - { - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - DmaBase0_reg = hmmc->Instance->IDMABASE0; - DmaBase1_reg = hmmc->Instance->IDMABASE1; - - if ((hmmc->Instance->IDMABSIZE == 0U) || (DmaBase0_reg == 0U) || (DmaBase1_reg == 0U)) - { - hmmc->ErrorCode = HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0; - - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - hmmc->State = HAL_MMC_STATE_BUSY; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= 512U; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - - hmmc->Instance->DCTRL |= SDMMC_DCTRL_FIFORST; - - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - hmmc->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_DOUBLE_BUFF0; - - /* Read Blocks in DMA mode */ - hmmc->Context = (MMC_CONTEXT_READ_MULTIPLE_BLOCK | MMC_CONTEXT_DMA); - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->State = HAL_MMC_STATE_READY; - hmmc->ErrorCode |= errorstate; - return HAL_ERROR; - } - - __HAL_MMC_ENABLE_IT(hmmc, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND | - SDMMC_FLAG_IDMATE | SDMMC_FLAG_IDMABTC)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } - -} - -/** - * @brief Write block(s) to a specified address in a card. The transferred Data are stored in Buffer0 and Buffer1. - * Buffer0, Buffer1 and BufferSize need to be configured by function HAL_MMCEx_ConfigDMAMultiBuffer before - * call this function. - * @param hmmc: MMC handle - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Total number of blocks to read - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMCEx_WriteBlocksDMAMultiBuffer(MMC_HandleTypeDef *hmmc, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t DmaBase0_reg; - uint32_t DmaBase1_reg; - uint32_t add = BlockAdd; - - if (hmmc->State == HAL_MMC_STATE_READY) - { - if ((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr)) - { - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Check the case of 4kB blocks (field DATA SECTOR SIZE of extended CSD register) */ - if (((hmmc->Ext_CSD[(MMC_EXT_CSD_DATA_SEC_SIZE_INDEX / 4)] >> MMC_EXT_CSD_DATA_SEC_SIZE_POS) & 0x000000FFU) != 0x0U) - { - if ((NumberOfBlocks % 8U) != 0U) - { - /* The number of blocks should be a multiple of 8 sectors of 512 bytes = 4 KBytes */ - hmmc->ErrorCode |= HAL_MMC_ERROR_BLOCK_LEN_ERR; - return HAL_ERROR; - } - - if ((BlockAdd % 8U) != 0U) - { - /* The address should be aligned to 8 (corresponding to 4 KBytes blocks) */ - hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_MISALIGNED; - return HAL_ERROR; - } - } - - DmaBase0_reg = hmmc->Instance->IDMABASE0; - DmaBase1_reg = hmmc->Instance->IDMABASE1; - - if ((hmmc->Instance->IDMABSIZE == 0U) || (DmaBase0_reg == 0U) || (DmaBase1_reg == 0U)) - { - hmmc->ErrorCode = HAL_MMC_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Initialize data control register */ - hmmc->Instance->DCTRL = 0; - - hmmc->ErrorCode = HAL_MMC_ERROR_NONE; - - hmmc->State = HAL_MMC_STATE_BUSY; - - if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD) - { - add *= 512U; - } - - /* Configure the MMC DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hmmc->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hmmc->Instance); - - hmmc->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_DOUBLE_BUFF0; - - /* Write Blocks in DMA mode */ - hmmc->Context = (MMC_CONTEXT_WRITE_MULTIPLE_BLOCK | MMC_CONTEXT_DMA); - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, add); - if (errorstate != HAL_MMC_ERROR_NONE) - { - hmmc->State = HAL_MMC_STATE_READY; - hmmc->ErrorCode |= errorstate; - return HAL_ERROR; - } - - __HAL_MMC_ENABLE_IT(hmmc, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND | - SDMMC_FLAG_IDMATE | SDMMC_FLAG_IDMABTC)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - - -/** - * @brief Change the DMA Buffer0 or Buffer1 address on the fly. - * @param hmmc: pointer to a MMC_HandleTypeDef structure. - * @param Buffer: the buffer to be changed, This parameter can be one of - * the following values: MMC_DMA_BUFFER0 or MMC_DMA_BUFFER1 - * @param pDataBuffer: The new address - * @note The BUFFER0 address can be changed only when the current transfer use - * BUFFER1 and the BUFFER1 address can be changed only when the current - * transfer use BUFFER0. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_MMCEx_ChangeDMABuffer(MMC_HandleTypeDef *hmmc, HAL_MMCEx_DMABuffer_MemoryTypeDef Buffer, - uint32_t *pDataBuffer) -{ - if (Buffer == MMC_DMA_BUFFER0) - { - /* change the buffer0 address */ - hmmc->Instance->IDMABASE0 = (uint32_t)pDataBuffer; - } - else - { - /* change the memory1 address */ - hmmc->Instance->IDMABASE1 = (uint32_t)pDataBuffer; - } - - return HAL_OK; -} - -/** - * @} - */ - -/** - * @} - */ - -#endif /* HAL_MMC_MODULE_ENABLED */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ - -/** - * @} - */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c b/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c deleted file mode 100644 index ae33c68..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c +++ /dev/null @@ -1,4150 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_sd.c - * @author MCD Application Team - * @brief SD card HAL module driver. - * This file provides firmware functions to manage the following - * functionalities of the Secure Digital (SD) peripheral: - * + Initialization and de-initialization functions - * + IO operation functions - * + Peripheral Control functions - * + Peripheral State functions - * - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - @verbatim - ============================================================================== - ##### How to use this driver ##### - ============================================================================== - [..] - This driver implements a high level communication layer for read and write from/to - this memory. The needed STM32 hardware resources (SDMMC and GPIO) are performed by - the user in HAL_SD_MspInit() function (MSP layer). - Basically, the MSP layer configuration should be the same as we provide in the - examples. - You can easily tailor this configuration according to hardware resources. - - [..] - This driver is a generic layered driver for SDMMC memories which uses the HAL - SDMMC driver functions to interface with SD and uSD cards devices. - It is used as follows: - - (#)Initialize the SDMMC low level resources by implementing the HAL_SD_MspInit() API: - (##) Enable the SDMMC interface clock using __HAL_RCC_SDMMC_CLK_ENABLE(); - (##) SDMMC pins configuration for SD card - (+++) Enable the clock for the SDMMC GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE(); - (+++) Configure these SDMMC pins as alternate function pull-up using HAL_GPIO_Init() - and according to your pin assignment; - (##) NVIC configuration if you need to use interrupt process (HAL_SD_ReadBlocks_IT() - and HAL_SD_WriteBlocks_IT() APIs). - (+++) Configure the SDMMC interrupt priorities using function HAL_NVIC_SetPriority(); - (+++) Enable the NVIC SDMMC IRQs using function HAL_NVIC_EnableIRQ() - (+++) SDMMC interrupts are managed using the macros __HAL_SD_ENABLE_IT() - and __HAL_SD_DISABLE_IT() inside the communication process. - (+++) SDMMC interrupts pending bits are managed using the macros __HAL_SD_GET_IT() - and __HAL_SD_CLEAR_IT() - (##) No general propose DMA Configuration is needed, an Internal DMA for SDMMC Peripheral are used. - - (#) At this stage, you can perform SD read/write/erase operations after SD card initialization - - *** SD Card Initialization and configuration *** - ================================================ - [..] - To initialize the SD Card, use the HAL_SD_Init() function. It Initializes - SDMMC Peripheral(STM32 side) and the SD Card, and put it into StandBy State (Ready for data transfer). - This function provide the following operations: - - (#) Apply the SD Card initialization process at 400KHz and check the SD Card - type (Standard Capacity or High Capacity). You can change or adapt this - frequency by adjusting the "ClockDiv" field. - The SD Card frequency (SDMMC_CK) is computed as follows: - - SDMMC_CK = SDMMCCLK / (2 * ClockDiv) - - In initialization mode and according to the SD Card standard, - make sure that the SDMMC_CK frequency doesn't exceed 400KHz. - - This phase of initialization is done through SDMMC_Init() and - SDMMC_PowerState_ON() SDMMC low level APIs. - - (#) Initialize the SD card. The API used is HAL_SD_InitCard(). - This phase allows the card initialization and identification - and check the SD Card type (Standard Capacity or High Capacity) - The initialization flow is compatible with SD standard. - - This API (HAL_SD_InitCard()) could be used also to reinitialize the card in case - of plug-off plug-in. - - (#) Configure the SD Card Data transfer frequency. You can change or adapt this - frequency by adjusting the "ClockDiv" field. - In transfer mode and according to the SD Card standard, make sure that the - SDMMC_CK frequency doesn't exceed 25MHz and 100MHz in High-speed mode switch. - - (#) Select the corresponding SD Card according to the address read with the step 2. - - (#) Configure the SD Card in wide bus mode: 4-bits data. - - *** SD Card Read operation *** - ============================== - [..] - (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_SD_GetCardState() function for SD card state. - - (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_SD_GetCardState() function for SD card state. - You could also check the DMA transfer process through the SD Rx interrupt event. - - (+) You can read from SD card in Interrupt mode by using function HAL_SD_ReadBlocks_IT(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_SD_GetCardState() function for SD card state. - You could also check the IT transfer process through the SD Rx interrupt event. - - *** SD Card Write operation *** - =============================== - [..] - (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_SD_GetCardState() function for SD card state. - - (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_SD_GetCardState() function for SD card state. - You could also check the DMA transfer process through the SD Tx interrupt event. - - (+) You can write to SD card in Interrupt mode by using function HAL_SD_WriteBlocks_IT(). - This function support only 512-bytes block length (the block size should be - chosen as 512 bytes). - You can choose either one block read operation or multiple block read operation - by adjusting the "NumberOfBlocks" parameter. - After this, you have to ensure that the transfer is done correctly. The check is done - through HAL_SD_GetCardState() function for SD card state. - You could also check the IT transfer process through the SD Tx interrupt event. - - *** SD card status *** - ====================== - [..] - (+) The SD Status contains status bits that are related to the SD Memory - Card proprietary features. To get SD card status use the HAL_SD_GetCardStatus(). - - *** SD card information *** - =========================== - [..] - (+) To get SD card information, you can use the function HAL_SD_GetCardInfo(). - It returns useful information about the SD card such as block size, card type, - block number ... - - *** SD card CSD register *** - ============================ - (+) The HAL_SD_GetCardCSD() API allows to get the parameters of the CSD register. - Some of the CSD parameters are useful for card initialization and identification. - - *** SD card CID register *** - ============================ - (+) The HAL_SD_GetCardCID() API allows to get the parameters of the CID register. - Some of the CSD parameters are useful for card initialization and identification. - - *** SD HAL driver macros list *** - ================================== - [..] - Below the list of most used macros in SD HAL driver. - - (+) __HAL_SD_ENABLE_IT: Enable the SD device interrupt - (+) __HAL_SD_DISABLE_IT: Disable the SD device interrupt - (+) __HAL_SD_GET_FLAG:Check whether the specified SD flag is set or not - (+) __HAL_SD_CLEAR_FLAG: Clear the SD's pending flags - - (@) You can refer to the SD HAL driver header file for more useful macros - - *** Callback registration *** - ============================================= - [..] - The compilation define USE_HAL_SD_REGISTER_CALLBACKS when set to 1 - allows the user to configure dynamically the driver callbacks. - - Use Functions HAL_SD_RegisterCallback() to register a user callback, - it allows to register following callbacks: - (+) TxCpltCallback : callback when a transmission transfer is completed. - (+) RxCpltCallback : callback when a reception transfer is completed. - (+) ErrorCallback : callback when error occurs. - (+) AbortCpltCallback : callback when abort is completed. - (+) Read_DMADblBuf0CpltCallback : callback when the DMA reception of first buffer is completed. - (+) Read_DMADblBuf1CpltCallback : callback when the DMA reception of second buffer is completed. - (+) Write_DMADblBuf0CpltCallback : callback when the DMA transmission of first buffer is completed. - (+) Write_DMADblBuf1CpltCallback : callback when the DMA transmission of second buffer is completed. - (+) MspInitCallback : SD MspInit. - (+) MspDeInitCallback : SD MspDeInit. - This function takes as parameters the HAL peripheral handle, the Callback ID - and a pointer to the user callback function. - For specific callbacks TransceiverCallback use dedicated register callbacks: - respectively HAL_SD_RegisterTransceiverCallback(). - - Use function HAL_SD_UnRegisterCallback() to reset a callback to the default - weak (overridden) function. It allows to reset following callbacks: - (+) TxCpltCallback : callback when a transmission transfer is completed. - (+) RxCpltCallback : callback when a reception transfer is completed. - (+) ErrorCallback : callback when error occurs. - (+) AbortCpltCallback : callback when abort is completed. - (+) Read_DMADblBuf0CpltCallback : callback when the DMA reception of first buffer is completed. - (+) Read_DMADblBuf1CpltCallback : callback when the DMA reception of second buffer is completed. - (+) Write_DMADblBuf0CpltCallback : callback when the DMA transmission of first buffer is completed. - (+) Write_DMADblBuf1CpltCallback : callback when the DMA transmission of second buffer is completed. - (+) MspInitCallback : SD MspInit. - (+) MspDeInitCallback : SD MspDeInit. - This function) takes as parameters the HAL peripheral handle and the Callback ID. - For specific callbacks TransceiverCallback use dedicated unregister callbacks: - respectively HAL_SD_UnRegisterTransceiverCallback(). - - By default, after the HAL_SD_Init and if the state is HAL_SD_STATE_RESET - all callbacks are reset to the corresponding legacy weak (overridden) functions. - Exception done for MspInit and MspDeInit callbacks that are respectively - reset to the legacy weak (overridden) functions in the HAL_SD_Init - and HAL_SD_DeInit only when these callbacks are null (not registered beforehand). - If not, MspInit or MspDeInit are not null, the HAL_SD_Init and HAL_SD_DeInit - keep and use the user MspInit/MspDeInit callbacks (registered beforehand) - - Callbacks can be registered/unregistered in READY state only. - Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered - in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used - during the Init/DeInit. - In that case first register the MspInit/MspDeInit user callbacks - using HAL_SD_RegisterCallback before calling HAL_SD_DeInit - or HAL_SD_Init function. - - When The compilation define USE_HAL_SD_REGISTER_CALLBACKS is set to 0 or - not defined, the callback registering feature is not available - and weak (overridden) callbacks are used. - - @endverbatim - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ - -/** @addtogroup SD - * @{ - */ - -#if defined (SDMMC1) || defined (SDMMC2) -#ifdef HAL_SD_MODULE_ENABLED - -/* Private typedef -----------------------------------------------------------*/ -/* Private define ------------------------------------------------------------*/ -/** @addtogroup SD_Private_Defines - * @{ - */ -/* Frequencies used in the driver for clock divider calculation */ -#define SD_INIT_FREQ 400000U /* Initialization phase : 400 kHz max */ -#define SD_NORMAL_SPEED_FREQ 25000000U /* Normal speed phase : 25 MHz max */ -#define SD_HIGH_SPEED_FREQ 50000000U /* High speed phase : 50 MHz max */ -/* Private macro -------------------------------------------------------------*/ -#if defined (DLYB_SDMMC1) && defined (DLYB_SDMMC2) -#define SD_GET_DLYB_INSTANCE(SDMMC_INSTANCE) (((SDMMC_INSTANCE) == SDMMC1)? \ - DLYB_SDMMC1 : DLYB_SDMMC2 ) -#elif defined (DLYB_SDMMC1) -#define SD_GET_DLYB_INSTANCE(SDMMC_INSTANCE) ( DLYB_SDMMC1 ) -#endif /* (DLYB_SDMMC1) && defined (DLYB_SDMMC2) */ - -/** - * @} - */ - -/* Private variables ---------------------------------------------------------*/ -/* Private function prototypes -----------------------------------------------*/ -/* Private functions ---------------------------------------------------------*/ -/** @defgroup SD_Private_Functions SD Private Functions - * @{ - */ -static uint32_t SD_InitCard(SD_HandleTypeDef *hsd); -static uint32_t SD_PowerON(SD_HandleTypeDef *hsd); -static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus); -static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus); -static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd); -static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd); -static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR); -static void SD_PowerOFF(SD_HandleTypeDef *hsd); -static void SD_Write_IT(SD_HandleTypeDef *hsd); -static void SD_Read_IT(SD_HandleTypeDef *hsd); -static uint32_t SD_SwitchSpeed(SD_HandleTypeDef *hsd, uint32_t SwitchSpeedMode); -#if (USE_SD_TRANSCEIVER != 0U) -static uint32_t SD_UltraHighSpeed(SD_HandleTypeDef *hsd, uint32_t UltraHighSpeedMode); -static uint32_t SD_DDR_Mode(SD_HandleTypeDef *hsd); -#endif /* USE_SD_TRANSCEIVER */ -/** - * @} - */ - -/* Exported functions --------------------------------------------------------*/ -/** @addtogroup SD_Exported_Functions - * @{ - */ - -/** @addtogroup SD_Exported_Functions_Group1 - * @brief Initialization and de-initialization functions - * -@verbatim - ============================================================================== - ##### Initialization and de-initialization functions ##### - ============================================================================== - [..] - This section provides functions allowing to initialize/de-initialize the SD - card device to be ready for use. - -@endverbatim - * @{ - */ - -/** - * @brief Initializes the SD according to the specified parameters in the - SD_HandleTypeDef and create the associated handle. - * @param hsd: Pointer to the SD handle - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd) -{ - HAL_SD_CardStatusTypeDef CardStatus; - uint32_t speedgrade; - uint32_t unitsize; - uint32_t tickstart; - - /* Check the SD handle allocation */ - if (hsd == NULL) - { - return HAL_ERROR; - } - - /* Check the parameters */ - assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance)); - assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge)); - assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave)); - assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide)); - assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl)); - assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv)); - - if (hsd->State == HAL_SD_STATE_RESET) - { - /* Allocate lock resource and initialize it */ - hsd->Lock = HAL_UNLOCKED; - -#if (USE_SD_TRANSCEIVER != 0U) - /* Force SDMMC_TRANSCEIVER_PRESENT for Legacy usage */ - if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN) - { - hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT; - } -#endif /*USE_SD_TRANSCEIVER */ -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - /* Reset Callback pointers in HAL_SD_STATE_RESET only */ - hsd->TxCpltCallback = HAL_SD_TxCpltCallback; - hsd->RxCpltCallback = HAL_SD_RxCpltCallback; - hsd->ErrorCallback = HAL_SD_ErrorCallback; - hsd->AbortCpltCallback = HAL_SD_AbortCallback; - hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback; - hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback; - hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback; - hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback; -#if (USE_SD_TRANSCEIVER != 0U) - if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT) - { - hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback; - } -#endif /* USE_SD_TRANSCEIVER */ - - if (hsd->MspInitCallback == NULL) - { - hsd->MspInitCallback = HAL_SD_MspInit; - } - - /* Init the low level hardware */ - hsd->MspInitCallback(hsd); -#else - /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */ - HAL_SD_MspInit(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - - hsd->State = HAL_SD_STATE_PROGRAMMING; - - /* Initialize the Card parameters */ - if (HAL_SD_InitCard(hsd) != HAL_OK) - { - return HAL_ERROR; - } - - if (HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK) - { - return HAL_ERROR; - } - /* Get Initial Card Speed from Card Status*/ - speedgrade = CardStatus.UhsSpeedGrade; - unitsize = CardStatus.UhsAllocationUnitSize; - if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U))) - { - hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED; - } - else - { - if (hsd->SdCard.CardType == CARD_SDHC_SDXC) - { - hsd->SdCard.CardSpeed = CARD_HIGH_SPEED; - } - else - { - hsd->SdCard.CardSpeed = CARD_NORMAL_SPEED; - } - - } - /* Configure the bus wide */ - if (HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK) - { - return HAL_ERROR; - } - - /* Verify that SD card is ready to use after Initialization */ - tickstart = HAL_GetTick(); - while ((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_TIMEOUT; - } - } - - /* Initialize the error code */ - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - /* Initialize the SD operation */ - hsd->Context = SD_CONTEXT_NONE; - - /* Initialize the SD state */ - hsd->State = HAL_SD_STATE_READY; - - return HAL_OK; -} - -/** - * @brief Initializes the SD Card. - * @param hsd: Pointer to SD handle - * @note This function initializes the SD card. It could be used when a card - re-initialization is needed. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd) -{ - uint32_t errorstate; - SD_InitTypeDef Init; - uint32_t sdmmc_clk; - - /* Default SDMMC peripheral configuration for SD card initialization */ - Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING; - Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE; - Init.BusWide = SDMMC_BUS_WIDE_1B; - Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE; - - /* Init Clock should be less or equal to 400Khz*/ - sdmmc_clk = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SDMMC); - if (sdmmc_clk == 0U) - { - hsd->State = HAL_SD_STATE_READY; - hsd->ErrorCode = SDMMC_ERROR_INVALID_PARAMETER; - return HAL_ERROR; - } - Init.ClockDiv = sdmmc_clk / (2U * SD_INIT_FREQ); - -#if (USE_SD_TRANSCEIVER != 0U) - Init.TranceiverPresent = hsd->Init.TranceiverPresent; - - if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT) - { - /* Set Transceiver polarity */ - hsd->Instance->POWER |= SDMMC_POWER_DIRPOL; - } -#elif defined (USE_SD_DIRPOL) - /* Set Transceiver polarity */ - hsd->Instance->POWER |= SDMMC_POWER_DIRPOL; -#endif /* USE_SD_TRANSCEIVER */ - - /* Initialize SDMMC peripheral interface with default configuration */ - (void)SDMMC_Init(hsd->Instance, Init); - - /* Set Power State to ON */ - (void)SDMMC_PowerState_ON(hsd->Instance); - - /* wait 74 Cycles: required power up waiting time before starting - the SD initialization sequence */ - if (Init.ClockDiv != 0U) - { - sdmmc_clk = sdmmc_clk / (2U * Init.ClockDiv); - } - - if (sdmmc_clk != 0U) - { - HAL_Delay(1U + (74U * 1000U / (sdmmc_clk))); - } - - /* Identify card operating voltage */ - errorstate = SD_PowerON(hsd); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->State = HAL_SD_STATE_READY; - hsd->ErrorCode |= errorstate; - return HAL_ERROR; - } - - /* Card initialization */ - errorstate = SD_InitCard(hsd); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->State = HAL_SD_STATE_READY; - hsd->ErrorCode |= errorstate; - return HAL_ERROR; - } - - /* Set Block Size for Card */ - errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - return HAL_ERROR; - } - - return HAL_OK; -} - -/** - * @brief De-Initializes the SD card. - * @param hsd: Pointer to SD handle - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd) -{ - /* Check the SD handle allocation */ - if (hsd == NULL) - { - return HAL_ERROR; - } - - /* Check the parameters */ - assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance)); - - hsd->State = HAL_SD_STATE_BUSY; - -#if (USE_SD_TRANSCEIVER != 0U) - /* Deactivate the 1.8V Mode */ - if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT) - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - if (hsd->DriveTransceiver_1_8V_Callback == NULL) - { - hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback; - } - hsd->DriveTransceiver_1_8V_Callback(RESET); -#else - HAL_SD_DriveTransceiver_1_8V_Callback(RESET); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } -#endif /* USE_SD_TRANSCEIVER */ - - /* Set SD power state to off */ - SD_PowerOFF(hsd); - -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - if (hsd->MspDeInitCallback == NULL) - { - hsd->MspDeInitCallback = HAL_SD_MspDeInit; - } - - /* DeInit the low level hardware */ - hsd->MspDeInitCallback(hsd); -#else - /* De-Initialize the MSP layer */ - HAL_SD_MspDeInit(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - - hsd->ErrorCode = HAL_SD_ERROR_NONE; - hsd->State = HAL_SD_STATE_RESET; - - return HAL_OK; -} - -/** - * @brief Initializes the SD MSP. - * @param hsd: Pointer to SD handle - * @retval None - */ -__weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SD_MspInit could be implemented in the user file - */ -} - -/** - * @brief De-Initialize SD MSP. - * @param hsd: Pointer to SD handle - * @retval None - */ -__weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SD_MspDeInit could be implemented in the user file - */ -} - -/** - * @} - */ - -/** @addtogroup SD_Exported_Functions_Group2 - * @brief Data transfer functions - * -@verbatim - ============================================================================== - ##### IO operation functions ##### - ============================================================================== - [..] - This subsection provides a set of functions allowing to manage the data - transfer from/to SD card. - -@endverbatim - * @{ - */ - -/** - * @brief Reads block(s) from a specified address in a card. The Data transfer - * is managed by polling mode. - * @note This API should be followed by a check on the card state through - * HAL_SD_GetCardState(). - * @param hsd: Pointer to SD handle - * @param pData: pointer to the buffer that will contain the received data - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Number of SD blocks to read - * @param Timeout: Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, - uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t data; - uint32_t dataremaining; - uint32_t add = BlockAdd; - uint8_t *tempbuff = pData; - - if (NULL == pData) - { - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - return HAL_ERROR; - } - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_BUSY; - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0U; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= BLOCKSIZE; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = NumberOfBlocks * BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - - /* Read block(s) in polling mode */ - if (NumberOfBlocks > 1U) - { - hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK; - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add); - } - else - { - hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK; - - /* Read Single Block command */ - errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add); - } - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - - /* Poll on SDMMC flags */ - dataremaining = config.DataLength; - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hsd->Instance); - *tempbuff = (uint8_t)(data & 0xFFU); - tempbuff++; - *tempbuff = (uint8_t)((data >> 8U) & 0xFFU); - tempbuff++; - *tempbuff = (uint8_t)((data >> 16U) & 0xFFU); - tempbuff++; - *tempbuff = (uint8_t)((data >> 24U) & 0xFFU); - tempbuff++; - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hsd->Instance); - - /* Send stop transmission command in case of multiblock read */ - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U)) - { - if (hsd->SdCard.CardType != CARD_SECURED) - { - /* Send stop transmission command */ - errorstate = SDMMC_CmdStopTransfer(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - } - } - - /* Get error state */ - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - hsd->State = HAL_SD_STATE_READY; - - return HAL_OK; - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_BUSY; - return HAL_ERROR; - } -} - -/** - * @brief Allows to write block(s) to a specified address in a card. The Data - * transfer is managed by polling mode. - * @note This API should be followed by a check on the card state through - * HAL_SD_GetCardState(). - * @param hsd: Pointer to SD handle - * @param pData: pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of SD blocks to write - * @param Timeout: Specify timeout value - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks, uint32_t Timeout) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t data; - uint32_t dataremaining; - uint32_t add = BlockAdd; - const uint8_t *tempbuff = pData; - - if (NULL == pData) - { - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - return HAL_ERROR; - } - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_BUSY; - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0U; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= BLOCKSIZE; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = NumberOfBlocks * BLOCKSIZE; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - - /* Write Blocks in Polling mode */ - if (NumberOfBlocks > 1U) - { - hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK; - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add); - } - else - { - hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK; - - /* Write Single Block command */ - errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add); - } - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - - /* Write block(s) in polling mode */ - dataremaining = config.DataLength; - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | - SDMMC_FLAG_DATAEND)) - { - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= SDMMC_FIFO_SIZE)) - { - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*tempbuff); - tempbuff++; - data |= ((uint32_t)(*tempbuff) << 8U); - tempbuff++; - data |= ((uint32_t)(*tempbuff) << 16U); - tempbuff++; - data |= ((uint32_t)(*tempbuff) << 24U); - tempbuff++; - (void)SDMMC_WriteFIFO(hsd->Instance, &data); - } - dataremaining -= SDMMC_FIFO_SIZE; - } - - if (((HAL_GetTick() - tickstart) >= Timeout) || (Timeout == 0U)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_TIMEOUT; - } - } - __SDMMC_CMDTRANS_DISABLE(hsd->Instance); - - /* Send stop transmission command in case of multiblock write */ - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U)) - { - if (hsd->SdCard.CardType != CARD_SECURED) - { - /* Send stop transmission command */ - errorstate = SDMMC_CmdStopTransfer(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - } - } - - /* Get error state */ - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR)) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - hsd->State = HAL_SD_STATE_READY; - - return HAL_OK; - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_BUSY; - return HAL_ERROR; - } -} - -/** - * @brief Reads block(s) from a specified address in a card. The Data transfer - * is managed in interrupt mode. - * @note This API should be followed by a check on the card state through - * HAL_SD_GetCardState(). - * @note You could also check the IT transfer process through the SD Rx - * interrupt event. - * @param hsd: Pointer to SD handle - * @param pData: Pointer to the buffer that will contain the received data - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Number of blocks to read. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - return HAL_ERROR; - } - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_BUSY; - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0U; - - hsd->pRxBuffPtr = pData; - hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= BLOCKSIZE; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - - /* Read Blocks in IT mode */ - if (NumberOfBlocks > 1U) - { - hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT); - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add); - } - else - { - hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT); - - /* Read Single Block command */ - errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add); - } - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - - __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND | - SDMMC_FLAG_RXFIFOHF)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Writes block(s) to a specified address in a card. The Data transfer - * is managed in interrupt mode. - * @note This API should be followed by a check on the card state through - * HAL_SD_GetCardState(). - * @note You could also check the IT transfer process through the SD Tx - * interrupt event. - * @param hsd: Pointer to SD handle - * @param pData: Pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of blocks to write - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - return HAL_ERROR; - } - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_BUSY; - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0U; - - hsd->pTxBuffPtr = pData; - hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= BLOCKSIZE; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - - /* Write Blocks in Polling mode */ - if (NumberOfBlocks > 1U) - { - hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_IT); - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add); - } - else - { - hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT); - - /* Write Single Block command */ - errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add); - } - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - - /* Enable transfer interrupts */ - __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND | - SDMMC_FLAG_TXFIFOHE)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Reads block(s) from a specified address in a card. The Data transfer - * is managed by DMA mode. - * @note This API should be followed by a check on the card state through - * HAL_SD_GetCardState(). - * @note You could also check the DMA transfer process through the SD Rx - * interrupt event. - * @param hsd: Pointer SD handle - * @param pData: Pointer to the buffer that will contain the received data - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Number of blocks to read. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - return HAL_ERROR; - } - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_BUSY; - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0U; - - hsd->pRxBuffPtr = pData; - hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= BLOCKSIZE; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - hsd->Instance->IDMABASE0 = (uint32_t) pData ; - hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF; - - /* Read Blocks in DMA mode */ - if (NumberOfBlocks > 1U) - { - hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA); - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add); - } - else - { - hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA); - - /* Read Single Block command */ - errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add); - } - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - - /* Enable transfer interrupts */ - __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Writes block(s) to a specified address in a card. The Data transfer - * is managed by DMA mode. - * @note This API should be followed by a check on the card state through - * HAL_SD_GetCardState(). - * @note You could also check the DMA transfer process through the SD Tx - * interrupt event. - * @param hsd: Pointer to SD handle - * @param pData: Pointer to the buffer that will contain the data to transmit - * @param BlockAdd: Block Address where data will be written - * @param NumberOfBlocks: Number of blocks to write - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, const uint8_t *pData, uint32_t BlockAdd, - uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t add = BlockAdd; - - if (NULL == pData) - { - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - return HAL_ERROR; - } - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_BUSY; - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0U; - - hsd->pTxBuffPtr = pData; - hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= BLOCKSIZE; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - - hsd->Instance->IDMABASE0 = (uint32_t) pData ; - hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF; - - /* Write Blocks in Polling mode */ - if (NumberOfBlocks > 1U) - { - hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA); - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add); - } - else - { - hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA); - - /* Write Single Block command */ - errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add); - } - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - return HAL_ERROR; - } - - /* Enable transfer interrupts */ - __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Erases the specified memory area of the given SD card. - * @note This API should be followed by a check on the card state through - * HAL_SD_GetCardState(). - * @param hsd: Pointer to SD handle - * @param BlockStartAdd: Start Block address - * @param BlockEndAdd: End Block address - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd) -{ - uint32_t errorstate; - uint32_t start_add = BlockStartAdd; - uint32_t end_add = BlockEndAdd; - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - if (end_add < start_add) - { - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - return HAL_ERROR; - } - - if (end_add > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_BUSY; - - /* Check if the card command class supports erase command */ - if (((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE; - hsd->State = HAL_SD_STATE_READY; - return HAL_ERROR; - } - - if ((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED; - hsd->State = HAL_SD_STATE_READY; - return HAL_ERROR; - } - - /* Get start and end block for high capacity cards */ - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - start_add *= BLOCKSIZE; - end_add *= BLOCKSIZE; - } - - /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */ - if (hsd->SdCard.CardType != CARD_SECURED) - { - /* Send CMD32 SD_ERASE_GRP_START with argument as addr */ - errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - return HAL_ERROR; - } - - /* Send CMD33 SD_ERASE_GRP_END with argument as addr */ - errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - return HAL_ERROR; - } - } - - /* Send CMD38 ERASE */ - errorstate = SDMMC_CmdErase(hsd->Instance, 0UL); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - return HAL_ERROR; - } - - hsd->State = HAL_SD_STATE_READY; - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief This function handles SD card interrupt request. - * @param hsd: Pointer to SD handle - * @retval None - */ -void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd) -{ - uint32_t errorstate; - uint32_t context = hsd->Context; - - /* Check for SDMMC interrupt flags */ - if ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U)) - { - SD_Read_IT(hsd); - } - - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) != RESET) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DATAEND); - - __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR | SDMMC_IT_TXFIFOHE | \ - SDMMC_IT_RXFIFOHF); - - __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_IDMABTC); - __SDMMC_CMDTRANS_DISABLE(hsd->Instance); - - if ((context & SD_CONTEXT_IT) != 0U) - { - if (((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)) - { - errorstate = SDMMC_CmdStopTransfer(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= errorstate; -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->ErrorCallback(hsd); -#else - HAL_SD_ErrorCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - } - - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U)) - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->RxCpltCallback(hsd); -#else - HAL_SD_RxCpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - else - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->TxCpltCallback(hsd); -#else - HAL_SD_TxCpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - } - else if ((context & SD_CONTEXT_DMA) != 0U) - { - hsd->Instance->DLEN = 0; - hsd->Instance->DCTRL = 0; - hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA; - - /* Stop Transfer for Write Multi blocks or Read Multi blocks */ - if (((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)) - { - errorstate = SDMMC_CmdStopTransfer(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= errorstate; -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->ErrorCallback(hsd); -#else - HAL_SD_ErrorCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - } - - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; - if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)) - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->TxCpltCallback(hsd); -#else - HAL_SD_TxCpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U)) - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->RxCpltCallback(hsd); -#else - HAL_SD_RxCpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - } - else - { - /* Nothing to do */ - } - } - - else if ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U)) - { - SD_Write_IT(hsd); - } - - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_RXOVERR | - SDMMC_FLAG_TXUNDERR) != RESET) - { - /* Set Error code */ - if (__HAL_SD_GET_FLAG(hsd, SDMMC_IT_DCRCFAIL) != RESET) - { - hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL; - } - if (__HAL_SD_GET_FLAG(hsd, SDMMC_IT_DTIMEOUT) != RESET) - { - hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT; - } - if (__HAL_SD_GET_FLAG(hsd, SDMMC_IT_RXOVERR) != RESET) - { - hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN; - } - if (__HAL_SD_GET_FLAG(hsd, SDMMC_IT_TXUNDERR) != RESET) - { - hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN; - } - - /* Clear All flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - /* Disable all interrupts */ - __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR); - - __SDMMC_CMDTRANS_DISABLE(hsd->Instance); - hsd->Instance->DCTRL |= SDMMC_DCTRL_FIFORST; - hsd->Instance->CMD |= SDMMC_CMD_CMDSTOP; - hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance); - hsd->Instance->CMD &= ~(SDMMC_CMD_CMDSTOP); - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DABORT); - - if ((context & SD_CONTEXT_IT) != 0U) - { - /* Set the SD state to ready to be able to start again the process */ - hsd->State = HAL_SD_STATE_READY; - hsd->Context = SD_CONTEXT_NONE; -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->ErrorCallback(hsd); -#else - HAL_SD_ErrorCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - else if ((context & SD_CONTEXT_DMA) != 0U) - { - if (hsd->ErrorCode != HAL_SD_ERROR_NONE) - { - /* Disable Internal DMA */ - __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_IDMABTC); - hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA; - - /* Set the SD state to ready to be able to start again the process */ - hsd->State = HAL_SD_STATE_READY; -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->ErrorCallback(hsd); -#else - HAL_SD_ErrorCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - } - else - { - /* Nothing to do */ - } - } - - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_IDMABTC) != RESET) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_IDMABTC); - if (READ_BIT(hsd->Instance->IDMACTRL, SDMMC_IDMA_IDMABACT) == 0U) - { - /* Current buffer is buffer0, Transfer complete for buffer1 */ - if ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U) - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->Write_DMADblBuf1CpltCallback(hsd); -#else - HAL_SDEx_Write_DMADoubleBuf1CpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - else /* SD_CONTEXT_READ_MULTIPLE_BLOCK */ - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->Read_DMADblBuf1CpltCallback(hsd); -#else - HAL_SDEx_Read_DMADoubleBuf1CpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - } - else /* SD_DMA_BUFFER1 */ - { - /* Current buffer is buffer1, Transfer complete for buffer0 */ - if ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U) - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->Write_DMADblBuf0CpltCallback(hsd); -#else - HAL_SDEx_Write_DMADoubleBuf0CpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - else /* SD_CONTEXT_READ_MULTIPLE_BLOCK */ - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->Read_DMADblBuf0CpltCallback(hsd); -#else - HAL_SDEx_Read_DMADoubleBuf0CpltCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - } - } - else - { - /* Nothing to do */ - } -} - -/** - * @brief return the SD state - * @param hsd: Pointer to sd handle - * @retval HAL state - */ -HAL_SD_StateTypeDef HAL_SD_GetState(const SD_HandleTypeDef *hsd) -{ - return hsd->State; -} - -/** - * @brief Return the SD error code - * @param hsd : Pointer to a SD_HandleTypeDef structure that contains - * the configuration information. - * @retval SD Error Code - */ -uint32_t HAL_SD_GetError(const SD_HandleTypeDef *hsd) -{ - return hsd->ErrorCode; -} - -/** - * @brief Tx Transfer completed callbacks - * @param hsd: Pointer to SD handle - * @retval None - */ -__weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SD_TxCpltCallback can be implemented in the user file - */ -} - -/** - * @brief Rx Transfer completed callbacks - * @param hsd: Pointer SD handle - * @retval None - */ -__weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SD_RxCpltCallback can be implemented in the user file - */ -} - -/** - * @brief SD error callbacks - * @param hsd: Pointer SD handle - * @retval None - */ -__weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SD_ErrorCallback can be implemented in the user file - */ -} - -/** - * @brief SD Abort callbacks - * @param hsd: Pointer SD handle - * @retval None - */ -__weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SD_AbortCallback can be implemented in the user file - */ -} - -#if (USE_SD_TRANSCEIVER != 0U) -/** - * @brief Enable/Disable the SD Transceiver 1.8V Mode Callback. - * @param status: Voltage Switch State - * @retval None - */ -__weak void HAL_SD_DriveTransceiver_1_8V_Callback(FlagStatus status) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(status); - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SD_EnableTransceiver could be implemented in the user file - */ -} -#endif /* USE_SD_TRANSCEIVER */ - -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) -/** - * @brief Register a User SD Callback - * To be used instead of the weak (overridden) predefined callback - * @note The HAL_SD_RegisterCallback() may be called before HAL_SD_Init() in - * HAL_SD_STATE_RESET to register callbacks for HAL_SD_MSP_INIT_CB_ID - * and HAL_SD_MSP_DEINIT_CB_ID. - * @param hsd : SD handle - * @param CallbackID : ID of the callback to be registered - * This parameter can be one of the following values: - * @arg @ref HAL_SD_TX_CPLT_CB_ID SD Tx Complete Callback ID - * @arg @ref HAL_SD_RX_CPLT_CB_ID SD Rx Complete Callback ID - * @arg @ref HAL_SD_ERROR_CB_ID SD Error Callback ID - * @arg @ref HAL_SD_ABORT_CB_ID SD Abort Callback ID - * @arg @ref HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Rx Double buffer 0 Callback ID - * @arg @ref HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Rx Double buffer 1 Callback ID - * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Tx Double buffer 0 Callback ID - * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Tx Double buffer 1 Callback ID - * @arg @ref HAL_SD_MSP_INIT_CB_ID SD MspInit Callback ID - * @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID - * @param pCallback : pointer to the Callback function - * @retval status - */ -HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, - pSD_CallbackTypeDef pCallback) -{ - HAL_StatusTypeDef status = HAL_OK; - - if (pCallback == NULL) - { - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - return HAL_ERROR; - } - - if (hsd->State == HAL_SD_STATE_READY) - { - switch (CallbackID) - { - case HAL_SD_TX_CPLT_CB_ID : - hsd->TxCpltCallback = pCallback; - break; - case HAL_SD_RX_CPLT_CB_ID : - hsd->RxCpltCallback = pCallback; - break; - case HAL_SD_ERROR_CB_ID : - hsd->ErrorCallback = pCallback; - break; - case HAL_SD_ABORT_CB_ID : - hsd->AbortCpltCallback = pCallback; - break; - case HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID : - hsd->Read_DMADblBuf0CpltCallback = pCallback; - break; - case HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID : - hsd->Read_DMADblBuf1CpltCallback = pCallback; - break; - case HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID : - hsd->Write_DMADblBuf0CpltCallback = pCallback; - break; - case HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID : - hsd->Write_DMADblBuf1CpltCallback = pCallback; - break; - case HAL_SD_MSP_INIT_CB_ID : - hsd->MspInitCallback = pCallback; - break; - case HAL_SD_MSP_DEINIT_CB_ID : - hsd->MspDeInitCallback = pCallback; - break; - default : - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else if (hsd->State == HAL_SD_STATE_RESET) - { - switch (CallbackID) - { - case HAL_SD_MSP_INIT_CB_ID : - hsd->MspInitCallback = pCallback; - break; - case HAL_SD_MSP_DEINIT_CB_ID : - hsd->MspDeInitCallback = pCallback; - break; - default : - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else - { - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - } - - return status; -} - -/** - * @brief Unregister a User SD Callback - * SD Callback is redirected to the weak (overridden) predefined callback - * @note The HAL_SD_UnRegisterCallback() may be called before HAL_SD_Init() in - * HAL_SD_STATE_RESET to register callbacks for HAL_SD_MSP_INIT_CB_ID - * and HAL_SD_MSP_DEINIT_CB_ID. - * @param hsd : SD handle - * @param CallbackID : ID of the callback to be unregistered - * This parameter can be one of the following values: - * @arg @ref HAL_SD_TX_CPLT_CB_ID SD Tx Complete Callback ID - * @arg @ref HAL_SD_RX_CPLT_CB_ID SD Rx Complete Callback ID - * @arg @ref HAL_SD_ERROR_CB_ID SD Error Callback ID - * @arg @ref HAL_SD_ABORT_CB_ID SD Abort Callback ID - * @arg @ref HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Rx Double buffer 0 Callback ID - * @arg @ref HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Rx Double buffer 1 Callback ID - * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID SD DMA Tx Double buffer 0 Callback ID - * @arg @ref HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID SD DMA Tx Double buffer 1 Callback ID - * @arg @ref HAL_SD_MSP_INIT_CB_ID SD MspInit Callback ID - * @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID - * @retval status - */ -HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID) -{ - HAL_StatusTypeDef status = HAL_OK; - - if (hsd->State == HAL_SD_STATE_READY) - { - switch (CallbackID) - { - case HAL_SD_TX_CPLT_CB_ID : - hsd->TxCpltCallback = HAL_SD_TxCpltCallback; - break; - case HAL_SD_RX_CPLT_CB_ID : - hsd->RxCpltCallback = HAL_SD_RxCpltCallback; - break; - case HAL_SD_ERROR_CB_ID : - hsd->ErrorCallback = HAL_SD_ErrorCallback; - break; - case HAL_SD_ABORT_CB_ID : - hsd->AbortCpltCallback = HAL_SD_AbortCallback; - break; - case HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID : - hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback; - break; - case HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID : - hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback; - break; - case HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID : - hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback; - break; - case HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID : - hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback; - break; - case HAL_SD_MSP_INIT_CB_ID : - hsd->MspInitCallback = HAL_SD_MspInit; - break; - case HAL_SD_MSP_DEINIT_CB_ID : - hsd->MspDeInitCallback = HAL_SD_MspDeInit; - break; - default : - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else if (hsd->State == HAL_SD_STATE_RESET) - { - switch (CallbackID) - { - case HAL_SD_MSP_INIT_CB_ID : - hsd->MspInitCallback = HAL_SD_MspInit; - break; - case HAL_SD_MSP_DEINIT_CB_ID : - hsd->MspDeInitCallback = HAL_SD_MspDeInit; - break; - default : - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - break; - } - } - else - { - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - } - - return status; -} - -#if (USE_SD_TRANSCEIVER != 0U) -/** - * @brief Register a User SD Transceiver Callback - * To be used instead of the weak (overridden) predefined callback - * @param hsd : SD handle - * @param pCallback : pointer to the Callback function - * @retval status - */ -HAL_StatusTypeDef HAL_SD_RegisterTransceiverCallback(SD_HandleTypeDef *hsd, pSD_TransceiverCallbackTypeDef pCallback) -{ - HAL_StatusTypeDef status = HAL_OK; - - if (pCallback == NULL) - { - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - return HAL_ERROR; - } - - /* Process locked */ - __HAL_LOCK(hsd); - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->DriveTransceiver_1_8V_Callback = pCallback; - } - else - { - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - } - - /* Release Lock */ - __HAL_UNLOCK(hsd); - return status; -} - -/** - * @brief Unregister a User SD Transceiver Callback - * SD Callback is redirected to the weak (overridden) predefined callback - * @param hsd : SD handle - * @retval status - */ -HAL_StatusTypeDef HAL_SD_UnRegisterTransceiverCallback(SD_HandleTypeDef *hsd) -{ - HAL_StatusTypeDef status = HAL_OK; - - /* Process locked */ - __HAL_LOCK(hsd); - - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback; - } - else - { - /* Update the error code */ - hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK; - /* update return status */ - status = HAL_ERROR; - } - - /* Release Lock */ - __HAL_UNLOCK(hsd); - return status; -} -#endif /* USE_SD_TRANSCEIVER */ -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - -/** - * @} - */ - -/** @addtogroup SD_Exported_Functions_Group3 - * @brief management functions - * -@verbatim - ============================================================================== - ##### Peripheral Control functions ##### - ============================================================================== - [..] - This subsection provides a set of functions allowing to control the SD card - operations and get the related information - -@endverbatim - * @{ - */ - -/** - * @brief Returns information the information of the card which are stored on - * the CID register. - * @param hsd: Pointer to SD handle - * @param pCID: Pointer to a HAL_SD_CardCIDTypeDef structure that - * contains all CID register parameters - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_GetCardCID(const SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID) -{ - pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U); - - pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U); - - pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U)); - - pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU); - - pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U); - - pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U)); - - pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U); - - pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U); - - pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U); - - pCID->Reserved2 = 1U; - - return HAL_OK; -} - -/** - * @brief Returns information the information of the card which are stored on - * the CSD register. - * @param hsd: Pointer to SD handle - * @param pCSD: Pointer to a HAL_SD_CardCSDTypeDef structure that - * contains all CSD register parameters - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD) -{ - pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U); - - pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U); - - pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U); - - pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U); - - pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U); - - pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU); - - pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U); - - pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U); - - pCSD->PartBlockRead = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U); - - pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U); - - pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U); - - pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U); - - pCSD->Reserved2 = 0U; /*!< Reserved */ - - if (hsd->SdCard.CardType == CARD_SDSC) - { - pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U)); - - pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U); - - pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U); - - pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U); - - pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U); - - pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U); - - hsd->SdCard.BlockNbr = (pCSD->DeviceSize + 1U) ; - hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U)); - hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU)); - - hsd->SdCard.LogBlockNbr = (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / BLOCKSIZE); - hsd->SdCard.LogBlockSize = BLOCKSIZE; - } - else if (hsd->SdCard.CardType == CARD_SDHC_SDXC) - { - /* Byte 7 */ - pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U)); - - hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U); - hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr; - hsd->SdCard.BlockSize = BLOCKSIZE; - hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize; - } - else - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - hsd->State = HAL_SD_STATE_READY; - return HAL_ERROR; - } - - pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U); - - pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U); - - pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU); - - pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U); - - pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U); - - pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U); - - pCSD->MaxWrBlockLen = (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U); - - pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U); - - pCSD->Reserved3 = 0; - - pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U); - - pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U); - - pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U); - - pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U); - - pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U); - - pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U); - - pCSD->ECC = (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U); - - pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U); - - pCSD->Reserved4 = 1; - - return HAL_OK; -} - -/** - * @brief Gets the SD status info.( shall be called if there is no SD transaction ongoing ) - * @param hsd: Pointer to SD handle - * @param pStatus: Pointer to the HAL_SD_CardStatusTypeDef structure that - * will contain the SD card status information - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus) -{ - uint32_t sd_status[16]; - uint32_t errorstate; - HAL_StatusTypeDef status = HAL_OK; - - if (hsd->State == HAL_SD_STATE_BUSY) - { - return HAL_ERROR; - } - - errorstate = SD_SendSDStatus(hsd, sd_status); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - hsd->State = HAL_SD_STATE_READY; - status = HAL_ERROR; - } - else - { - pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U); - - pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U); - - pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U)); - - pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U) | ((sd_status[1] & 0xFF00U) << 8U) | - ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U)); - - pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU); - - pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U); - - pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U); - - pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU)); - - pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U); - - pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U); - - pStatus->UhsSpeedGrade = (uint8_t)((sd_status[3] & 0x00F0U) >> 4U); - pStatus->UhsAllocationUnitSize = (uint8_t)(sd_status[3] & 0x000FU) ; - pStatus->VideoSpeedClass = (uint8_t)((sd_status[4] & 0xFF000000U) >> 24U); - } - - /* Set Block Size for Card */ - errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode = errorstate; - hsd->State = HAL_SD_STATE_READY; - status = HAL_ERROR; - } - - return status; -} - -/** - * @brief Gets the SD card info. - * @param hsd: Pointer to SD handle - * @param pCardInfo: Pointer to the HAL_SD_CardInfoTypeDef structure that - * will contain the SD card status information - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_GetCardInfo(const SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo) -{ - pCardInfo->CardType = (uint32_t)(hsd->SdCard.CardType); - pCardInfo->CardVersion = (uint32_t)(hsd->SdCard.CardVersion); - pCardInfo->Class = (uint32_t)(hsd->SdCard.Class); - pCardInfo->RelCardAdd = (uint32_t)(hsd->SdCard.RelCardAdd); - pCardInfo->BlockNbr = (uint32_t)(hsd->SdCard.BlockNbr); - pCardInfo->BlockSize = (uint32_t)(hsd->SdCard.BlockSize); - pCardInfo->LogBlockNbr = (uint32_t)(hsd->SdCard.LogBlockNbr); - pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize); - - return HAL_OK; -} - -/** - * @brief Enables wide bus operation for the requested card if supported by - * card. - * @param hsd: Pointer to SD handle - * @param WideMode: Specifies the SD card wide bus mode - * This parameter can be one of the following values: - * @arg SDMMC_BUS_WIDE_8B: 8-bit data transfer - * @arg SDMMC_BUS_WIDE_4B: 4-bit data transfer - * @arg SDMMC_BUS_WIDE_1B: 1-bit data transfer - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode) -{ - SDMMC_InitTypeDef Init; - uint32_t errorstate; - uint32_t sdmmc_clk; - - HAL_StatusTypeDef status = HAL_OK; - - /* Check the parameters */ - assert_param(IS_SDMMC_BUS_WIDE(WideMode)); - - /* Change State */ - hsd->State = HAL_SD_STATE_BUSY; - - if (hsd->SdCard.CardType != CARD_SECURED) - { - if (WideMode == SDMMC_BUS_WIDE_8B) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - } - else if (WideMode == SDMMC_BUS_WIDE_4B) - { - errorstate = SD_WideBus_Enable(hsd); - - hsd->ErrorCode |= errorstate; - } - else if (WideMode == SDMMC_BUS_WIDE_1B) - { - errorstate = SD_WideBus_Disable(hsd); - - hsd->ErrorCode |= errorstate; - } - else - { - /* WideMode is not a valid argument*/ - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - } - } - else - { - /* SD Card does not support this feature */ - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - } - - if (hsd->ErrorCode != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - status = HAL_ERROR; - } - else - { - sdmmc_clk = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SDMMC); - if (sdmmc_clk != 0U) - { - /* Configure the SDMMC peripheral */ - Init.ClockEdge = hsd->Init.ClockEdge; - Init.ClockPowerSave = hsd->Init.ClockPowerSave; - Init.BusWide = WideMode; - Init.HardwareFlowControl = hsd->Init.HardwareFlowControl; - - /* Check if user Clock div < Normal speed 25Mhz, no change in Clockdiv */ - if (hsd->Init.ClockDiv >= (sdmmc_clk / (2U * SD_NORMAL_SPEED_FREQ))) - { - Init.ClockDiv = hsd->Init.ClockDiv; - } - else if (hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) - { - /* UltraHigh speed SD card,user Clock div */ - Init.ClockDiv = hsd->Init.ClockDiv; - } - else if (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) - { - /* High speed SD card, Max Frequency = 50Mhz */ - if (hsd->Init.ClockDiv == 0U) - { - if (sdmmc_clk > SD_HIGH_SPEED_FREQ) - { - Init.ClockDiv = sdmmc_clk / (2U * SD_HIGH_SPEED_FREQ); - } - else - { - Init.ClockDiv = hsd->Init.ClockDiv; - } - } - else - { - if ((sdmmc_clk / (2U * hsd->Init.ClockDiv)) > SD_HIGH_SPEED_FREQ) - { - Init.ClockDiv = sdmmc_clk / (2U * SD_HIGH_SPEED_FREQ); - } - else - { - Init.ClockDiv = hsd->Init.ClockDiv; - } - } - } - else - { - /* No High speed SD card, Max Frequency = 25Mhz */ - if (hsd->Init.ClockDiv == 0U) - { - if (sdmmc_clk > SD_NORMAL_SPEED_FREQ) - { - Init.ClockDiv = sdmmc_clk / (2U * SD_NORMAL_SPEED_FREQ); - } - else - { - Init.ClockDiv = hsd->Init.ClockDiv; - } - } - else - { - if ((sdmmc_clk / (2U * hsd->Init.ClockDiv)) > SD_NORMAL_SPEED_FREQ) - { - Init.ClockDiv = sdmmc_clk / (2U * SD_NORMAL_SPEED_FREQ); - } - else - { - Init.ClockDiv = hsd->Init.ClockDiv; - } - } - } - -#if (USE_SD_TRANSCEIVER != 0U) - Init.TranceiverPresent = hsd->Init.TranceiverPresent; -#endif /* USE_SD_TRANSCEIVER */ - - (void)SDMMC_Init(hsd->Instance, Init); - } - else - { - hsd->ErrorCode |= SDMMC_ERROR_INVALID_PARAMETER; - status = HAL_ERROR; - } - } - - /* Set Block Size for Card */ - errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - status = HAL_ERROR; - } - - /* Change State */ - hsd->State = HAL_SD_STATE_READY; - - return status; -} - -/** - * @brief Configure the speed bus mode - * @param hsd: Pointer to the SD handle - * @param SpeedMode: Specifies the SD card speed bus mode - * This parameter can be one of the following values: - * @arg SDMMC_SPEED_MODE_AUTO: Max speed mode supported by the card - * @arg SDMMC_SPEED_MODE_DEFAULT: Default Speed/SDR12 mode - * @arg SDMMC_SPEED_MODE_HIGH: High Speed/SDR25 mode - * @arg SDMMC_SPEED_MODE_ULTRA: Ultra high speed mode - * @retval HAL status - */ - -HAL_StatusTypeDef HAL_SD_ConfigSpeedBusOperation(SD_HandleTypeDef *hsd, uint32_t SpeedMode) -{ - uint32_t tickstart; - uint32_t errorstate; - HAL_StatusTypeDef status = HAL_OK; - - /* Check the parameters */ - assert_param(IS_SDMMC_SPEED_MODE(SpeedMode)); - /* Change State */ - hsd->State = HAL_SD_STATE_BUSY; - -#if (USE_SD_TRANSCEIVER != 0U) - if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT) - { - switch (SpeedMode) - { - case SDMMC_SPEED_MODE_AUTO: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - hsd->Instance->CLKCR |= SDMMC_CLKCR_BUSSPEED; - /* Enable Ultra High Speed */ - if (SD_UltraHighSpeed(hsd, SDMMC_SDR104_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - if (SD_SwitchSpeed(hsd, SDMMC_SDR25_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - } - } - else if (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) - { - /* Enable High Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR25_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - } - else - { - /*Nothing to do, Use defaultSpeed */ - } - break; - } - case SDMMC_SPEED_MODE_ULTRA_SDR104: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable UltraHigh Speed */ - if (SD_UltraHighSpeed(hsd, SDMMC_SDR104_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - hsd->Instance->CLKCR |= SDMMC_CLKCR_BUSSPEED; - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_ULTRA_SDR50: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable UltraHigh Speed */ - if (SD_UltraHighSpeed(hsd, SDMMC_SDR50_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - hsd->Instance->CLKCR |= SDMMC_CLKCR_BUSSPEED; - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_DDR: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable DDR Mode*/ - if (SD_DDR_Mode(hsd) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - hsd->Instance->CLKCR |= SDMMC_CLKCR_BUSSPEED | SDMMC_CLKCR_DDR; - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_HIGH: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable High Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR25_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_DEFAULT: - { - /* Switch to default Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR12_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - - break; - } - default: - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - status = HAL_ERROR; - break; - } - } - else - { - switch (SpeedMode) - { - case SDMMC_SPEED_MODE_AUTO: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable High Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR25_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - } - else - { - /*Nothing to do, Use defaultSpeed */ - } - break; - } - case SDMMC_SPEED_MODE_HIGH: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable High Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR25_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_DEFAULT: - { - /* Switch to default Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR12_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - - break; - } - case SDMMC_SPEED_MODE_ULTRA: /*not valid without transceiver*/ - default: - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - status = HAL_ERROR; - break; - } - } -#else - switch (SpeedMode) - { - case SDMMC_SPEED_MODE_AUTO: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable High Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR25_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - } - else - { - /*Nothing to do, Use defaultSpeed */ - } - break; - } - case SDMMC_SPEED_MODE_HIGH: - { - if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) || - (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) || - (hsd->SdCard.CardType == CARD_SDHC_SDXC)) - { - /* Enable High Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR25_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - } - else - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - break; - } - case SDMMC_SPEED_MODE_DEFAULT: - { - /* Switch to default Speed */ - if (SD_SwitchSpeed(hsd, SDMMC_SDR12_SWITCH_PATTERN) != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE; - status = HAL_ERROR; - } - - break; - } - case SDMMC_SPEED_MODE_ULTRA: /*not valid without transceiver*/ - default: - hsd->ErrorCode |= HAL_SD_ERROR_PARAM; - status = HAL_ERROR; - break; - } -#endif /* USE_SD_TRANSCEIVER */ - - /* Verify that SD card is ready to use after Speed mode switch*/ - tickstart = HAL_GetTick(); - while ((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_TIMEOUT; - } - } - - /* Set Block Size for Card */ - errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE); - if (errorstate != HAL_SD_ERROR_NONE) - { - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); - hsd->ErrorCode |= errorstate; - status = HAL_ERROR; - } - - /* Change State */ - hsd->State = HAL_SD_STATE_READY; - return status; -} - -/** - * @brief Gets the current sd card data state. - * @param hsd: pointer to SD handle - * @retval Card state - */ -HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd) -{ - uint32_t cardstate; - uint32_t errorstate; - uint32_t resp1 = 0; - - errorstate = SD_SendStatus(hsd, &resp1); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= errorstate; - } - - cardstate = ((resp1 >> 9U) & 0x0FU); - - return (HAL_SD_CardStateTypeDef)cardstate; -} - -/** - * @brief Abort the current transfer and disable the SD. - * @param hsd: pointer to a SD_HandleTypeDef structure that contains - * the configuration information for SD module. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd) -{ - uint32_t error_code; - uint32_t tickstart; - - if (hsd->State == HAL_SD_STATE_BUSY) - { - /* DIsable All interrupts */ - __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR); - __SDMMC_CMDTRANS_DISABLE(hsd->Instance); - - /*we will send the CMD12 in all cases in order to stop the data transfers*/ - /*In case the data transfer just finished , the external memory will not respond - and will return HAL_SD_ERROR_CMD_RSP_TIMEOUT*/ - /*In case the data transfer aborted , the external memory will respond and will return HAL_SD_ERROR_NONE*/ - /*Other scenario will return HAL_ERROR*/ - - hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance); - error_code = hsd->ErrorCode; - if ((error_code != HAL_SD_ERROR_NONE) && (error_code != HAL_SD_ERROR_CMD_RSP_TIMEOUT)) - { - return HAL_ERROR; - } - - tickstart = HAL_GetTick(); - if ((hsd->Instance->DCTRL & SDMMC_DCTRL_DTDIR) == SDMMC_TRANSFER_DIR_TO_CARD) - { - if (hsd->ErrorCode == HAL_SD_ERROR_NONE) - { - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DABORT | SDMMC_FLAG_BUSYD0END)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_TIMEOUT; - } - } - } - - if (hsd->ErrorCode == HAL_SD_ERROR_CMD_RSP_TIMEOUT) - { - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_TIMEOUT; - } - } - } - } - else if ((hsd->Instance->DCTRL & SDMMC_DCTRL_DTDIR) == SDMMC_TRANSFER_DIR_TO_SDMMC) - { - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DABORT | SDMMC_FLAG_DATAEND)) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_TIMEOUT; - } - } - } - else - { - /* Nothing to do*/ - } - - /*The reason of all these while conditions previously is that we need to wait the SDMMC and clear - the appropriate flags that will be set depending of the abort/non abort of the memory */ - /*Not waiting the SDMMC flags will cause the next SDMMC_DISABLE_IDMA to not get cleared - and will result in next SDMMC read/write operation to fail */ - - /*SDMMC ready for clear data flags*/ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_BUSYD0END); - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - /* If IDMA Context, disable Internal DMA */ - hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA; - - hsd->State = HAL_SD_STATE_READY; - - /* Initialize the SD operation */ - hsd->Context = SD_CONTEXT_NONE; - } - return HAL_OK; -} - -/** - * @brief Abort the current transfer and disable the SD (IT mode). - * @param hsd: pointer to a SD_HandleTypeDef structure that contains - * the configuration information for SD module. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd) -{ - HAL_SD_CardStateTypeDef CardState; - - /* Disable All interrupts */ - __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | \ - SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR); - - /* If IDMA Context, disable Internal DMA */ - hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA; - - /* Clear All flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - CardState = HAL_SD_GetCardState(hsd); - hsd->State = HAL_SD_STATE_READY; - - if ((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING)) - { - hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance); - } - - if (hsd->ErrorCode != HAL_SD_ERROR_NONE) - { - return HAL_ERROR; - } - else - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->AbortCpltCallback(hsd); -#else - HAL_SD_AbortCallback(hsd); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - } - - return HAL_OK; -} - -/** - * @} - */ - -/** - * @} - */ - -/* Private function ----------------------------------------------------------*/ -/** @addtogroup SD_Private_Functions - * @{ - */ - -/** - * @brief Initializes the sd card. - * @param hsd: Pointer to SD handle - * @retval SD Card error state - */ -static uint32_t SD_InitCard(SD_HandleTypeDef *hsd) -{ - HAL_SD_CardCSDTypeDef CSD; - uint32_t errorstate; - uint16_t sd_rca = 0U; - uint32_t tickstart = HAL_GetTick(); - - /* Check the power State */ - if (SDMMC_GetPowerState(hsd->Instance) == 0U) - { - /* Power off */ - return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE; - } - - if (hsd->SdCard.CardType != CARD_SECURED) - { - /* Send CMD2 ALL_SEND_CID */ - errorstate = SDMMC_CmdSendCID(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - else - { - /* Get Card identification number data */ - hsd->CID[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1); - hsd->CID[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2); - hsd->CID[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3); - hsd->CID[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4); - } - } - - if (hsd->SdCard.CardType != CARD_SECURED) - { - /* Send CMD3 SET_REL_ADDR with argument 0 */ - /* SD Card publishes its RCA. */ - while (sd_rca == 0U) - { - errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - if ((HAL_GetTick() - tickstart) >= SDMMC_CMDTIMEOUT) - { - return HAL_SD_ERROR_TIMEOUT; - } - } - } - if (hsd->SdCard.CardType != CARD_SECURED) - { - /* Get the SD card RCA */ - hsd->SdCard.RelCardAdd = sd_rca; - - /* Send CMD9 SEND_CSD with argument as card's RCA */ - errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U)); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - else - { - /* Get Card Specific Data */ - hsd->CSD[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1); - hsd->CSD[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2); - hsd->CSD[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3); - hsd->CSD[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4); - } - } - - /* Get the Card Class */ - hsd->SdCard.Class = (SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2) >> 20U); - - /* Get CSD parameters */ - if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK) - { - return HAL_SD_ERROR_UNSUPPORTED_FEATURE; - } - - /* Select the Card */ - errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U)); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* All cards are initialized */ - return HAL_SD_ERROR_NONE; -} - -/** - * @brief Enquires cards about their operating voltage and configures clock - * controls and stores SD information that will be needed in future - * in the SD handle. - * @param hsd: Pointer to SD handle - * @retval error state - */ -static uint32_t SD_PowerON(SD_HandleTypeDef *hsd) -{ - __IO uint32_t count = 0U; - uint32_t response = 0U; - uint32_t validvoltage = 0U; - uint32_t errorstate; -#if (USE_SD_TRANSCEIVER != 0U) - uint32_t tickstart = HAL_GetTick(); -#endif /* USE_SD_TRANSCEIVER */ - - /* CMD0: GO_IDLE_STATE */ - errorstate = SDMMC_CmdGoIdleState(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */ - errorstate = SDMMC_CmdOperCond(hsd->Instance); - if (errorstate == SDMMC_ERROR_TIMEOUT) /* No response to CMD8 */ - { - hsd->SdCard.CardVersion = CARD_V1_X; - /* CMD0: GO_IDLE_STATE */ - errorstate = SDMMC_CmdGoIdleState(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - } - else - { - hsd->SdCard.CardVersion = CARD_V2_X; - } - - if (hsd->SdCard.CardVersion == CARD_V2_X) - { - /* SEND CMD55 APP_CMD with RCA as 0 */ - errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0); - if (errorstate != HAL_SD_ERROR_NONE) - { - return HAL_SD_ERROR_UNSUPPORTED_FEATURE; - } - } - /* SD CARD */ - /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */ - while ((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U)) - { - /* SEND CMD55 APP_CMD with RCA as 0 */ - errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Send CMD41 */ - errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | - SD_SWITCH_1_8V_CAPACITY); - if (errorstate != HAL_SD_ERROR_NONE) - { - return HAL_SD_ERROR_UNSUPPORTED_FEATURE; - } - - /* Get command response */ - response = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1); - - /* Get operating voltage*/ - validvoltage = (((response >> 31U) == 1U) ? 1U : 0U); - - count++; - } - - if (count >= SDMMC_MAX_VOLT_TRIAL) - { - return HAL_SD_ERROR_INVALID_VOLTRANGE; - } - - /* Set default card type */ - hsd->SdCard.CardType = CARD_SDSC; - - if ((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) - { - hsd->SdCard.CardType = CARD_SDHC_SDXC; -#if (USE_SD_TRANSCEIVER != 0U) - if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT) - { - if ((response & SD_SWITCH_1_8V_CAPACITY) == SD_SWITCH_1_8V_CAPACITY) - { - hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED; - - /* Start switching procedue */ - hsd->Instance->POWER |= SDMMC_POWER_VSWITCHEN; - - /* Send CMD11 to switch 1.8V mode */ - errorstate = SDMMC_CmdVoltageSwitch(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Check to CKSTOP */ - while ((hsd->Instance->STA & SDMMC_FLAG_CKSTOP) != SDMMC_FLAG_CKSTOP) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - return HAL_SD_ERROR_TIMEOUT; - } - } - - /* Clear CKSTOP Flag */ - hsd->Instance->ICR = SDMMC_FLAG_CKSTOP; - - /* Check to BusyD0 */ - if ((hsd->Instance->STA & SDMMC_FLAG_BUSYD0) != SDMMC_FLAG_BUSYD0) - { - /* Error when activate Voltage Switch in SDMMC Peripheral */ - return SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - else - { - /* Enable Transceiver Switch PIN */ -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->DriveTransceiver_1_8V_Callback(SET); -#else - HAL_SD_DriveTransceiver_1_8V_Callback(SET); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ - - /* Switch ready */ - hsd->Instance->POWER |= SDMMC_POWER_VSWITCH; - - /* Check VSWEND Flag */ - while ((hsd->Instance->STA & SDMMC_FLAG_VSWEND) != SDMMC_FLAG_VSWEND) - { - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - return HAL_SD_ERROR_TIMEOUT; - } - } - - /* Clear VSWEND Flag */ - hsd->Instance->ICR = SDMMC_FLAG_VSWEND; - - /* Check BusyD0 status */ - if ((hsd->Instance->STA & SDMMC_FLAG_BUSYD0) == SDMMC_FLAG_BUSYD0) - { - /* Error when enabling 1.8V mode */ - return HAL_SD_ERROR_INVALID_VOLTRANGE; - } - /* Switch to 1.8V OK */ - - /* Disable VSWITCH FLAG from SDMMC Peripheral */ - hsd->Instance->POWER = 0x13U; - - /* Clean Status flags */ - hsd->Instance->ICR = 0xFFFFFFFFU; - } - } - } -#endif /* USE_SD_TRANSCEIVER */ - } - - return HAL_SD_ERROR_NONE; -} - -/** - * @brief Turns the SDMMC output signals off. - * @param hsd: Pointer to SD handle - * @retval None - */ -static void SD_PowerOFF(SD_HandleTypeDef *hsd) -{ - /* Set Power State to OFF */ - (void)SDMMC_PowerState_OFF(hsd->Instance); -} - -/** - * @brief Send Status info command. - * @param hsd: pointer to SD handle - * @param pSDstatus: Pointer to the buffer that will contain the SD card status - * SD Status register) - * @retval error state - */ -static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t count; - uint32_t *pData = pSDstatus; - - /* Check SD response */ - if ((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED) - { - return HAL_SD_ERROR_LOCK_UNLOCK_FAILED; - } - - /* Set block size for card if it is not equal to current block size for card */ - errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_NONE; - return errorstate; - } - - /* Send CMD55 */ - errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U)); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_NONE; - return errorstate; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = 64U; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_ENABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - - /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */ - errorstate = SDMMC_CmdStatusRegister(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->ErrorCode |= HAL_SD_ERROR_NONE; - return errorstate; - } - - /* Get status data */ - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND)) - { - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF)) - { - for (count = 0U; count < 8U; count++) - { - *pData = SDMMC_ReadFIFO(hsd->Instance); - pData++; - } - } - - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - return HAL_SD_ERROR_TIMEOUT; - } - } - - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT)) - { - return HAL_SD_ERROR_DATA_TIMEOUT; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)) - { - return HAL_SD_ERROR_DATA_CRC_FAIL; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR)) - { - return HAL_SD_ERROR_RX_OVERRUN; - } - else - { - /* Nothing to do */ - } - - while ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DPSMACT))) - { - *pData = SDMMC_ReadFIFO(hsd->Instance); - pData++; - - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - return HAL_SD_ERROR_TIMEOUT; - } - } - - /* Clear all the static status flags*/ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - return HAL_SD_ERROR_NONE; -} - -/** - * @brief Returns the current card's status. - * @param hsd: Pointer to SD handle - * @param pCardStatus: pointer to the buffer that will contain the SD card - * status (Card Status register) - * @retval error state - */ -static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus) -{ - uint32_t errorstate; - - if (pCardStatus == NULL) - { - return HAL_SD_ERROR_PARAM; - } - - /* Send Status command */ - errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U)); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Get SD card status */ - *pCardStatus = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1); - - return HAL_SD_ERROR_NONE; -} - -/** - * @brief Enables the SDMMC wide bus mode. - * @param hsd: pointer to SD handle - * @retval error state - */ -static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd) -{ - uint32_t scr[2U] = {0UL, 0UL}; - uint32_t errorstate; - - if ((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED) - { - return HAL_SD_ERROR_LOCK_UNLOCK_FAILED; - } - - /* Get SCR Register */ - errorstate = SD_FindSCR(hsd, scr); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* If requested card supports wide bus operation */ - if ((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO) - { - /* Send CMD55 APP_CMD with argument as card's RCA.*/ - errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U)); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */ - errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - return HAL_SD_ERROR_NONE; - } - else - { - return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE; - } -} - -/** - * @brief Disables the SDMMC wide bus mode. - * @param hsd: Pointer to SD handle - * @retval error state - */ -static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd) -{ - uint32_t scr[2U] = {0UL, 0UL}; - uint32_t errorstate; - - if ((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED) - { - return HAL_SD_ERROR_LOCK_UNLOCK_FAILED; - } - - /* Get SCR Register */ - errorstate = SD_FindSCR(hsd, scr); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* If requested card supports 1 bit mode operation */ - if ((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO) - { - /* Send CMD55 APP_CMD with argument as card's RCA */ - errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U)); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */ - errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - return HAL_SD_ERROR_NONE; - } - else - { - return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE; - } -} - -/** - * @brief Finds the SD card SCR register value. - * @param hsd: Pointer to SD handle - * @param pSCR: pointer to the buffer that will contain the SCR value - * @retval error state - */ -static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t tickstart = HAL_GetTick(); - uint32_t index = 0U; - uint32_t tempscr[2U] = {0UL, 0UL}; - uint32_t *scr = pSCR; - - /* Set Block Size To 8 Bytes */ - errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Send CMD55 APP_CMD with argument as card's RCA */ - errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U)); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = 8U; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_8B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_ENABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - - /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */ - errorstate = SDMMC_CmdSendSCR(hsd->Instance); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND | - SDMMC_FLAG_DATAEND)) - { - if ((!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOE)) && (index == 0U)) - { - tempscr[0] = SDMMC_ReadFIFO(hsd->Instance); - tempscr[1] = SDMMC_ReadFIFO(hsd->Instance); - index++; - } - - if ((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT) - { - return HAL_SD_ERROR_TIMEOUT; - } - } - - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT); - - return HAL_SD_ERROR_DATA_TIMEOUT; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL); - - return HAL_SD_ERROR_DATA_CRC_FAIL; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR); - - return HAL_SD_ERROR_RX_OVERRUN; - } - else - { - /* No error flag set */ - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24U) | ((tempscr[1] & SDMMC_8TO15BITS) << 8U) | \ - ((tempscr[1] & SDMMC_16TO23BITS) >> 8U) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24U)); - scr++; - *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24U) | ((tempscr[0] & SDMMC_8TO15BITS) << 8U) | \ - ((tempscr[0] & SDMMC_16TO23BITS) >> 8U) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24U)); - - } - - return HAL_SD_ERROR_NONE; -} - -/** - * @brief Wrap up reading in non-blocking mode. - * @param hsd: pointer to a SD_HandleTypeDef structure that contains - * the configuration information. - * @retval None - */ -static void SD_Read_IT(SD_HandleTypeDef *hsd) -{ - uint32_t count; - uint32_t data; - uint8_t *tmp; - - tmp = hsd->pRxBuffPtr; - - if (hsd->RxXferSize >= SDMMC_FIFO_SIZE) - { - /* Read data from SDMMC Rx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = SDMMC_ReadFIFO(hsd->Instance); - *tmp = (uint8_t)(data & 0xFFU); - tmp++; - *tmp = (uint8_t)((data >> 8U) & 0xFFU); - tmp++; - *tmp = (uint8_t)((data >> 16U) & 0xFFU); - tmp++; - *tmp = (uint8_t)((data >> 24U) & 0xFFU); - tmp++; - } - - hsd->pRxBuffPtr = tmp; - hsd->RxXferSize -= SDMMC_FIFO_SIZE; - } -} - -/** - * @brief Wrap up writing in non-blocking mode. - * @param hsd: pointer to a SD_HandleTypeDef structure that contains - * the configuration information. - * @retval None - */ -static void SD_Write_IT(SD_HandleTypeDef *hsd) -{ - uint32_t count; - uint32_t data; - const uint8_t *tmp; - - tmp = hsd->pTxBuffPtr; - - if (hsd->TxXferSize >= SDMMC_FIFO_SIZE) - { - /* Write data to SDMMC Tx FIFO */ - for (count = 0U; count < (SDMMC_FIFO_SIZE / 4U); count++) - { - data = (uint32_t)(*tmp); - tmp++; - data |= ((uint32_t)(*tmp) << 8U); - tmp++; - data |= ((uint32_t)(*tmp) << 16U); - tmp++; - data |= ((uint32_t)(*tmp) << 24U); - tmp++; - (void)SDMMC_WriteFIFO(hsd->Instance, &data); - } - - hsd->pTxBuffPtr = tmp; - hsd->TxXferSize -= SDMMC_FIFO_SIZE; - } -} - -/** - * @brief Switches the SD card to High Speed mode. - * This API must be used after "Transfer State" - * @note This operation should be followed by the configuration - * of PLL to have SDMMCCK clock between 25 and 50 MHz - * @param hsd: SD handle - * @param SwitchSpeedMode: SD speed mode( SDMMC_SDR12_SWITCH_PATTERN, SDMMC_SDR25_SWITCH_PATTERN) - * @retval SD Card error state - */ -uint32_t SD_SwitchSpeed(SD_HandleTypeDef *hsd, uint32_t SwitchSpeedMode) -{ - uint32_t errorstate = HAL_SD_ERROR_NONE; - SDMMC_DataInitTypeDef sdmmc_datainitstructure; - uint32_t SD_hs[16] = {0}; - uint32_t count; - uint32_t loop = 0 ; - uint32_t Timeout = HAL_GetTick(); - - if (hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED) - { - /* Standard Speed Card <= 12.5Mhz */ - return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE; - } - - if (hsd->SdCard.CardSpeed >= CARD_HIGH_SPEED) - { - /* Initialize the Data control register */ - hsd->Instance->DCTRL = 0; - errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U); - - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT; - sdmmc_datainitstructure.DataLength = 64U; - sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ; - sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE; - - (void)SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure); - - errorstate = SDMMC_CmdSwitch(hsd->Instance, SwitchSpeedMode); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND | - SDMMC_FLAG_DATAEND)) - { - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF)) - { - for (count = 0U; count < 8U; count++) - { - SD_hs[(8U * loop) + count] = SDMMC_ReadFIFO(hsd->Instance); - } - loop ++; - } - if ((HAL_GetTick() - Timeout) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_SD_ERROR_TIMEOUT; - } - } - - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT); - - return errorstate; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL); - - errorstate = SDMMC_ERROR_DATA_CRC_FAIL; - - return errorstate; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR); - - errorstate = SDMMC_ERROR_RX_OVERRUN; - - return errorstate; - } - else - { - /* No error flag set */ - } - - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - /* Test if the switch mode HS is ok */ - if ((((uint8_t *)SD_hs)[13] & 2U) != 2U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - - } - - return errorstate; -} - -#if (USE_SD_TRANSCEIVER != 0U) -/** - * @brief Switches the SD card to Ultra High Speed mode. - * This API must be used after "Transfer State" - * @note This operation should be followed by the configuration - * of PLL to have SDMMCCK clock between 50 and 120 MHz - * @param hsd: SD handle - * @param UltraHighSpeedMode: SD speed mode( SDMMC_SDR50_SWITCH_PATTERN, SDMMC_SDR104_SWITCH_PATTERN) - * @retval SD Card error state - */ -static uint32_t SD_UltraHighSpeed(SD_HandleTypeDef *hsd, uint32_t UltraHighSpeedMode) -{ - uint32_t errorstate = HAL_SD_ERROR_NONE; - SDMMC_DataInitTypeDef sdmmc_datainitstructure; - uint32_t SD_hs[16] = {0}; - uint32_t count; - uint32_t loop = 0 ; - uint32_t Timeout = HAL_GetTick(); - - if (hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED) - { - /* Standard Speed Card <= 12.5Mhz */ - return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE; - } - - if (hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) - { - /* Initialize the Data control register */ - hsd->Instance->DCTRL = 0; - errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U); - - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT; - sdmmc_datainitstructure.DataLength = 64U; - sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ; - sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE; - - if (SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK) - { - return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR); - } - - errorstate = SDMMC_CmdSwitch(hsd->Instance, UltraHighSpeedMode); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND | - SDMMC_FLAG_DATAEND)) - { - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF)) - { - for (count = 0U; count < 8U; count++) - { - SD_hs[(8U * loop) + count] = SDMMC_ReadFIFO(hsd->Instance); - } - loop ++; - } - - if ((HAL_GetTick() - Timeout) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_SD_ERROR_TIMEOUT; - } - } - - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT); - - return errorstate; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL); - - errorstate = SDMMC_ERROR_DATA_CRC_FAIL; - - return errorstate; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR); - - errorstate = SDMMC_ERROR_RX_OVERRUN; - - return errorstate; - } - else - { - /* No error flag set */ - } - - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - /* Test if the switch mode HS is ok */ - if ((((uint8_t *)SD_hs)[13] & 2U) != 2U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - else - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->DriveTransceiver_1_8V_Callback(SET); -#else - HAL_SD_DriveTransceiver_1_8V_Callback(SET); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ -#if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2) - /* Enable DelayBlock Peripheral */ - /* SDMMC_FB_CLK tuned feedback clock selected as receive clock, for SDR104 */ - MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX, SDMMC_CLKCR_SELCLKRX_1); - if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK) - { - return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR); - } -#endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */ - } - } - - return errorstate; -} - -/** - * @brief Switches the SD card to Double Data Rate (DDR) mode. - * This API must be used after "Transfer State" - * @note This operation should be followed by the configuration - * of PLL to have SDMMCCK clock less than 50MHz - * @param hsd: SD handle - * @retval SD Card error state - */ -static uint32_t SD_DDR_Mode(SD_HandleTypeDef *hsd) -{ - uint32_t errorstate = HAL_SD_ERROR_NONE; - SDMMC_DataInitTypeDef sdmmc_datainitstructure; - uint32_t SD_hs[16] = {0}; - uint32_t count; - uint32_t loop = 0 ; - uint32_t Timeout = HAL_GetTick(); - - if (hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED) - { - /* Standard Speed Card <= 12.5Mhz */ - return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE; - } - - if (hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) - { - /* Initialize the Data control register */ - hsd->Instance->DCTRL = 0; - errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U); - - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT; - sdmmc_datainitstructure.DataLength = 64U; - sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ; - sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE; - - if (SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK) - { - return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR); - } - - errorstate = SDMMC_CmdSwitch(hsd->Instance, SDMMC_DDR50_SWITCH_PATTERN); - if (errorstate != HAL_SD_ERROR_NONE) - { - return errorstate; - } - - while (!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND | - SDMMC_FLAG_DATAEND)) - { - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF)) - { - for (count = 0U; count < 8U; count++) - { - SD_hs[(8U * loop) + count] = SDMMC_ReadFIFO(hsd->Instance); - } - loop ++; - } - - if ((HAL_GetTick() - Timeout) >= SDMMC_SWDATATIMEOUT) - { - hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT; - hsd->State = HAL_SD_STATE_READY; - return HAL_SD_ERROR_TIMEOUT; - } - } - - if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT); - - return errorstate; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL); - - errorstate = SDMMC_ERROR_DATA_CRC_FAIL; - - return errorstate; - } - else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR)) - { - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR); - - errorstate = SDMMC_ERROR_RX_OVERRUN; - - return errorstate; - } - else - { - /* No error flag set */ - } - - /* Clear all the static flags */ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - /* Test if the switch mode is ok */ - if ((((uint8_t *)SD_hs)[13] & 2U) != 2U) - { - errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE; - } - else - { -#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U) - hsd->DriveTransceiver_1_8V_Callback(SET); -#else - HAL_SD_DriveTransceiver_1_8V_Callback(SET); -#endif /* USE_HAL_SD_REGISTER_CALLBACKS */ -#if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2) - /* Enable DelayBlock Peripheral */ - /* SDMMC_CKin feedback clock selected as receive clock, for DDR50 */ - MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX, SDMMC_CLKCR_SELCLKRX_0); - if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK) - { - return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR); - } -#endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */ - } - } - - return errorstate; -} - -#endif /* USE_SD_TRANSCEIVER */ - -/** - * @brief Read DMA Buffer 0 Transfer completed callbacks - * @param hsd: SD handle - * @retval None - */ -__weak void HAL_SDEx_Read_DMADoubleBuf0CpltCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SDEx_Read_DMADoubleBuf0CpltCallback can be implemented in the user file - */ -} - -/** - * @brief Read DMA Buffer 1 Transfer completed callbacks - * @param hsd: SD handle - * @retval None - */ -__weak void HAL_SDEx_Read_DMADoubleBuf1CpltCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SDEx_Read_DMADoubleBuf1CpltCallback can be implemented in the user file - */ -} - -/** - * @brief Write DMA Buffer 0 Transfer completed callbacks - * @param hsd: SD handle - * @retval None - */ -__weak void HAL_SDEx_Write_DMADoubleBuf0CpltCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SDEx_Write_DMADoubleBuf0CpltCallback can be implemented in the user file - */ -} - -/** - * @brief Write DMA Buffer 1 Transfer completed callbacks - * @param hsd: SD handle - * @retval None - */ -__weak void HAL_SDEx_Write_DMADoubleBuf1CpltCallback(SD_HandleTypeDef *hsd) -{ - /* Prevent unused argument(s) compilation warning */ - UNUSED(hsd); - - /* NOTE : This function should not be modified, when the callback is needed, - the HAL_SDEx_Write_DMADoubleBuf1CpltCallback can be implemented in the user file - */ -} - -/** - * @} - */ - -#endif /* HAL_SD_MODULE_ENABLED */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ - -/** - * @} - */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c b/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c deleted file mode 100644 index aa50d0b..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c +++ /dev/null @@ -1,315 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_hal_sd_ex.c - * @author MCD Application Team - * @brief SD card Extended HAL module driver. - * This file provides firmware functions to manage the following - * functionalities of the Secure Digital (SD) peripheral: - * + Extended features functions - * - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - @verbatim - ============================================================================== - ##### How to use this driver ##### - ============================================================================== - [..] - The SD Extension HAL driver can be used as follows: - (+) Configure Buffer0 and Buffer1 start address and Buffer size using HAL_SDEx_ConfigDMAMultiBuffer() function. - (+) Start Read and Write for multibuffer mode using HAL_SDEx_ReadBlocksDMAMultiBuffer() - and HAL_SDEx_WriteBlocksDMAMultiBuffer() functions. - - @endverbatim - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ - -/** @defgroup SDEx SDEx - * @brief SD Extended HAL module driver - * @{ - */ - -#if defined (SDMMC1) || defined (SDMMC2) -#ifdef HAL_SD_MODULE_ENABLED - -/* Private typedef -----------------------------------------------------------*/ -/* Private define ------------------------------------------------------------*/ -/* Private macro -------------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -/* Private function prototypes -----------------------------------------------*/ -/* Private functions ---------------------------------------------------------*/ -/* Exported functions --------------------------------------------------------*/ -/** @addtogroup SDEx_Exported_Functions - * @{ - */ - -/** @addtogroup SDEx_Exported_Functions_Group1 - * @brief Multibuffer functions - * -@verbatim - ============================================================================== - ##### Multibuffer functions ##### - ============================================================================== - [..] - This section provides functions allowing to configure the multibuffer mode and start read and write - multibuffer mode for SD HAL driver. - -@endverbatim - * @{ - */ - -/** - * @brief Configure DMA Dual Buffer mode. The Data transfer is managed by an Internal DMA. - * @param hsd: SD handle - * @param pDataBuffer0: Pointer to the buffer0 that will contain/receive the transferred data - * @param pDataBuffer1: Pointer to the buffer1 that will contain/receive the transferred data - * @param BufferSize: Size of Buffer0 in Blocks. Buffer0 and Buffer1 must have the same size. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SDEx_ConfigDMAMultiBuffer(SD_HandleTypeDef *hsd, uint32_t *pDataBuffer0, uint32_t *pDataBuffer1, - uint32_t BufferSize) -{ - if (hsd->State == HAL_SD_STATE_READY) - { - hsd->Instance->IDMABASE0 = (uint32_t) pDataBuffer0; - hsd->Instance->IDMABASE1 = (uint32_t) pDataBuffer1; - hsd->Instance->IDMABSIZE = (uint32_t)(BLOCKSIZE * BufferSize); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - -/** - * @brief Reads block(s) from a specified address in a card. The received Data will be stored in Buffer0 and Buffer1. - * Buffer0, Buffer1 and BufferSize need to be configured by function HAL_SDEx_ConfigDMAMultiBuffer before - * call this function. - * @param hsd: SD handle - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Total number of blocks to read - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SDEx_ReadBlocksDMAMultiBuffer(SD_HandleTypeDef *hsd, uint32_t BlockAdd, uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t DmaBase0_reg; - uint32_t DmaBase1_reg; - uint32_t add = BlockAdd; - - if (hsd->State == HAL_SD_STATE_READY) - { - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - DmaBase0_reg = hsd->Instance->IDMABASE0; - DmaBase1_reg = hsd->Instance->IDMABASE1; - - if ((hsd->Instance->IDMABSIZE == 0U) || (DmaBase0_reg == 0U) || (DmaBase1_reg == 0U)) - { - hsd->ErrorCode = HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0; - /* Clear old Flags*/ - __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS); - - hsd->ErrorCode = HAL_SD_ERROR_NONE; - hsd->State = HAL_SD_STATE_BUSY; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= 512U; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - - hsd->Instance->DCTRL |= SDMMC_DCTRL_FIFORST; - - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - - hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_DOUBLE_BUFF0; - - /* Read Blocks in DMA mode */ - hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA); - - /* Read Multi Block command */ - errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->State = HAL_SD_STATE_READY; - hsd->ErrorCode |= errorstate; - return HAL_ERROR; - } - - __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND | - SDMMC_IT_IDMABTC)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } - -} - -/** - * @brief Write block(s) to a specified address in a card. The transferred Data are stored in Buffer0 and Buffer1. - * Buffer0, Buffer1 and BufferSize need to be configured by function HAL_SDEx_ConfigDMAMultiBuffer before - * call this function. - * @param hsd: SD handle - * @param BlockAdd: Block Address from where data is to be read - * @param NumberOfBlocks: Total number of blocks to read - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SDEx_WriteBlocksDMAMultiBuffer(SD_HandleTypeDef *hsd, uint32_t BlockAdd, uint32_t NumberOfBlocks) -{ - SDMMC_DataInitTypeDef config; - uint32_t errorstate; - uint32_t DmaBase0_reg; - uint32_t DmaBase1_reg; - uint32_t add = BlockAdd; - - if (hsd->State == HAL_SD_STATE_READY) - { - if ((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)) - { - hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - DmaBase0_reg = hsd->Instance->IDMABASE0; - DmaBase1_reg = hsd->Instance->IDMABASE1; - if ((hsd->Instance->IDMABSIZE == 0U) || (DmaBase0_reg == 0U) || (DmaBase1_reg == 0U)) - { - hsd->ErrorCode = HAL_SD_ERROR_ADDR_OUT_OF_RANGE; - return HAL_ERROR; - } - - /* Initialize data control register */ - hsd->Instance->DCTRL = 0; - - hsd->ErrorCode = HAL_SD_ERROR_NONE; - - hsd->State = HAL_SD_STATE_BUSY; - - if (hsd->SdCard.CardType != CARD_SDHC_SDXC) - { - add *= 512U; - } - - /* Configure the SD DPSM (Data Path State Machine) */ - config.DataTimeOut = SDMMC_DATATIMEOUT; - config.DataLength = BLOCKSIZE * NumberOfBlocks; - config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B; - config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD; - config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK; - config.DPSM = SDMMC_DPSM_DISABLE; - (void)SDMMC_ConfigData(hsd->Instance, &config); - - __SDMMC_CMDTRANS_ENABLE(hsd->Instance); - - hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_DOUBLE_BUFF0; - - /* Write Blocks in DMA mode */ - hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA); - - /* Write Multi Block command */ - errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add); - if (errorstate != HAL_SD_ERROR_NONE) - { - hsd->State = HAL_SD_STATE_READY; - hsd->ErrorCode |= errorstate; - return HAL_ERROR; - } - - __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND | - SDMMC_IT_IDMABTC)); - - return HAL_OK; - } - else - { - return HAL_BUSY; - } -} - - -/** - * @brief Change the DMA Buffer0 or Buffer1 address on the fly. - * @param hsd: pointer to a SD_HandleTypeDef structure. - * @param Buffer: the buffer to be changed, This parameter can be one of - * the following values: SD_DMA_BUFFER0 or SD_DMA_BUFFER1 - * @param pDataBuffer: The new address - * @note The BUFFER0 address can be changed only when the current transfer use - * BUFFER1 and the BUFFER1 address can be changed only when the current - * transfer use BUFFER0. - * @retval HAL status - */ -HAL_StatusTypeDef HAL_SDEx_ChangeDMABuffer(SD_HandleTypeDef *hsd, HAL_SDEx_DMABuffer_MemoryTypeDef Buffer, - uint32_t *pDataBuffer) -{ - if (Buffer == SD_DMA_BUFFER0) - { - /* change the buffer0 address */ - hsd->Instance->IDMABASE0 = (uint32_t)pDataBuffer; - } - else - { - /* change the memory1 address */ - hsd->Instance->IDMABASE1 = (uint32_t)pDataBuffer; - } - - return HAL_OK; -} - - -/** - * @} - */ - -/** - * @} - */ - -#endif /* HAL_SD_MODULE_ENABLED */ -#endif /* SDMMC1 || SDMMC2 */ - -/** - * @} - */ - -/** - * @} - */ diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c b/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c deleted file mode 100644 index d7ac9bc..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c +++ /dev/null @@ -1,214 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_ll_delayblock.c - * @author MCD Application Team - * @brief DelayBlock Low Layer HAL module driver. - * - * This file provides firmware functions to manage the following - * functionalities of the Delay Block peripheral: - * + input clock frequency range 25MHz to 208MHz - * + up to 12 oversampling phases - * - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - @verbatim - ============================================================================== - ##### DelayBlock peripheral features ##### - ============================================================================== - [..] The Delay block is used to generate an Output clock which is de-phased from the Input - clock. The phase of the Output clock is programmed by FW. The Output clock is then used - to clock the receive data in i.e. a SDMMC or QSPI interface. - The delay is Voltage and Temperature dependent, which may require FW to do re-tuning - and recenter the Output clock phase to the receive data. - - [..] The Delay Block features include the following: - (+) Input clock frequency range 25MHz to 208MHz. - (+) Up to 12 oversampling phases. - - ##### How to use this driver ##### - ============================================================================== - [..] - This driver is a considered as a driver of service for external devices drivers - that interfaces with the DELAY peripheral. - The DelayBlock_Enable() function, enables the DelayBlock instance, configure the delay line length - and configure the Output clock phase. - The DelayBlock_Disable() function, disables the DelayBlock instance by setting DEN flag to 0. - - - @endverbatim - */ - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ - -/** @defgroup DELAYBLOCK_LL DELAYBLOCK_LL - * @brief Low layer module for Delay Block - * @{ - */ - -#if defined(HAL_SD_MODULE_ENABLED) || defined(HAL_QSPI_MODULE_ENABLED) - -/* Private typedef -----------------------------------------------------------*/ -/* Private define ------------------------------------------------------------*/ -/** @defgroup DelayBlock_LL_Private_Defines Delay Block Low Layer Private Defines - * @{ - */ -#define DLYB_TIMEOUT 0xFFU -/** - * @} - */ -/* Private macro -------------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -/* Private function prototypes -----------------------------------------------*/ -/* Exported functions --------------------------------------------------------*/ - -/** @defgroup DelayBlock_LL_Exported_Functions Delay Block Low Layer Exported Functions - * @{ - */ - -/** @defgroup HAL_DELAY_LL_Group1 Initialization de-initialization functions - * @brief Initialization and Configuration functions - * -@verbatim - =============================================================================== - ##### Initialization and de-initialization functions ##### - =============================================================================== - [..] This section provides functions allowing to: - -@endverbatim - * @{ - */ - - -/** - * @brief Enable the Delay Block instance. - * @param DLYBx: Pointer to DLYB instance. - * @retval HAL status - */ -HAL_StatusTypeDef DelayBlock_Enable(DLYB_TypeDef *DLYBx) -{ - uint32_t unit = 0U; - uint32_t sel = 0U; - uint32_t sel_current; - uint32_t unit_current; - uint32_t tuning; - uint32_t lng_mask; - uint32_t tickstart; - - DLYBx->CR = DLYB_CR_DEN | DLYB_CR_SEN; - - for (sel_current = 0U; sel_current < DLYB_MAX_SELECT; sel_current++) - { - /* lng_mask is the mask bit for the LNG field to check the output of the UNITx*/ - lng_mask = DLYB_CFGR_LNG_0 << sel_current; - tuning = 0U; - for (unit_current = 0U; unit_current < DLYB_MAX_UNIT; unit_current++) - { - /* Set the Delay of the UNIT(s)*/ - DLYBx->CFGR = DLYB_MAX_SELECT | (unit_current << DLYB_CFGR_UNIT_Pos); - - /* Waiting for a LNG valid value */ - tickstart = HAL_GetTick(); - while ((DLYBx->CFGR & DLYB_CFGR_LNGF) == 0U) - { - if((HAL_GetTick() - tickstart) >= DLYB_TIMEOUT) - { - return HAL_TIMEOUT; - } - } - if (tuning == 0U) - { - if ((DLYBx->CFGR & lng_mask) != 0U) - { - /* 1/2 period HIGH is detected */ - tuning = 1U; - } - } - else - { - /* 1/2 period LOW detected after the HIGH 1/2 period => FULL PERIOD passed*/ - if((DLYBx->CFGR & lng_mask ) == 0U) - { - /* Save the first result */ - if( unit == 0U ) - { - unit = unit_current; - sel = sel_current + 1U; - } - break; - } - } - } - } - - /* Apply the Tuning settings */ - DLYBx->CR = 0U; - DLYBx->CR = DLYB_CR_DEN | DLYB_CR_SEN; - DLYBx->CFGR = sel | (unit << DLYB_CFGR_UNIT_Pos); - DLYBx->CR = DLYB_CR_DEN; - - return HAL_OK; -} - -/** - * @brief Disable the Delay Block instance. - * @param DLYBx: Pointer to DLYB instance. - * @retval HAL status - */ -HAL_StatusTypeDef DelayBlock_Disable(DLYB_TypeDef *DLYBx) -{ - /* Disable DLYB */ - DLYBx->CR = 0U; - return HAL_OK; -} - -/** - * @brief Configure the Delay Block instance. - * @param DLYBx: Pointer to DLYB instance. - * @param PhaseSel: Phase selection [0..11]. - * @param Units: Delay units[0..127]. - * @retval HAL status - */ -HAL_StatusTypeDef DelayBlock_Configure(DLYB_TypeDef *DLYBx,uint32_t PhaseSel, uint32_t Units ) -{ - /* Apply the delay settings */ - - DLYBx->CR = 0U; - DLYBx->CR = DLYB_CR_DEN | DLYB_CR_SEN; - DLYBx->CFGR = PhaseSel | (Units << DLYB_CFGR_UNIT_Pos); - DLYBx->CR = DLYB_CR_DEN; - - return HAL_OK; -} - - -/** - * @} - */ - -/** - * @} - */ - -#endif /* (HAL_SD_MODULE_ENABLED) & (HAL_QSPI_MODULE_ENABLED)*/ -/** - * @} - */ - -/** - * @} - */ - diff --git a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c b/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c deleted file mode 100644 index dd39836..0000000 --- a/Software/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c +++ /dev/null @@ -1,1874 +0,0 @@ -/** - ****************************************************************************** - * @file stm32h7xx_ll_sdmmc.c - * @author MCD Application Team - * @brief SDMMC Low Layer HAL module driver. - * - * This file provides firmware functions to manage the following - * functionalities of the SDMMC peripheral: - * + Initialization/de-initialization functions - * + I/O operation functions - * + Peripheral Control functions - * + Peripheral State functions - * - ****************************************************************************** - * @attention - * - * Copyright (c) 2017 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - @verbatim - ============================================================================== - ##### SDMMC peripheral features ##### - ============================================================================== - [..] The SD/SDMMC MMC card host interface (SDMMC) provides an interface between the AHB - peripheral bus and MultiMedia cards (MMCs), SD memory cards, SDMMC cards and CE-ATA - devices. - - [..] The SDMMC features include the following: - (+) Full compliance with MultiMediaCard System Specification Version 4.51. Card support - for three different databus modes: 1-bit (default), 4-bit and 8-bit. - (+) Full compatibility with previous versions of MultiMediaCards (backward compatibility). - (+) Full compliance with SD memory card specifications version 4.1. - (SDR104 SDMMC_CK speed limited to maximum allowed IO speed, SPI mode and - UHS-II mode not supported). - (+) Full compliance with SDIO card specification version 4.0. Card support - for two different databus modes: 1-bit (default) and 4-bit. - (SDR104 SDMMC_CK speed limited to maximum allowed IO speed, SPI mode and - UHS-II mode not supported). - (+) Data transfer up to 208 Mbyte/s for the 8 bit mode. (depending maximum allowed IO speed). - (+) Data and command output enable signals to control external bidirectional drivers - - ##### How to use this driver ##### - ============================================================================== - [..] - This driver is a considered as a driver of service for external devices drivers - that interfaces with the SDMMC peripheral. - According to the device used (SD card/ MMC card / SDMMC card ...), a set of APIs - is used in the device's driver to perform SDMMC operations and functionalities. - - This driver is almost transparent for the final user, it is only used to implement other - functionalities of the external device. - - [..] - (+) The SDMMC clock is coming from output of PLL1_Q or PLL2_R. - Before start working with SDMMC peripheral make sure that the PLL is well configured. - The SDMMC peripheral uses two clock signals: - (++) PLL1_Q bus clock (default after reset) - (++) PLL2_R bus clock - - (+) Enable/Disable peripheral clock using RCC peripheral macros related to SDMMC - peripheral. - - (+) Enable the Power ON State using the SDMMC_PowerState_ON(SDMMCx) - function and disable it using the function SDMMC_PowerState_OFF(SDMMCx). - - (+) Enable/Disable the peripheral interrupts using the macros __SDMMC_ENABLE_IT(hSDMMC, IT) - and __SDMMC_DISABLE_IT(hSDMMC, IT) if you need to use interrupt mode. - - (+) When using the DMA mode - (++) Configure the IDMA mode (Single buffer or double) - (++) Configure the buffer address - (++) Configure Data Path State Machine - - (+) To control the CPSM (Command Path State Machine) and send - commands to the card use the SDMMC_SendCommand(SDMMCx), - SDMMC_GetCommandResponse() and SDMMC_GetResponse() functions. First, user has - to fill the command structure (pointer to SDMMC_CmdInitTypeDef) according - to the selected command to be sent. - The parameters that should be filled are: - (++) Command Argument - (++) Command Index - (++) Command Response type - (++) Command Wait - (++) CPSM Status (Enable or Disable). - - -@@- To check if the command is well received, read the SDMMC_CMDRESP - register using the SDMMC_GetCommandResponse(). - The SDMMC responses registers (SDMMC_RESP1 to SDMMC_RESP2), use the - SDMMC_GetResponse() function. - - (+) To control the DPSM (Data Path State Machine) and send/receive - data to/from the card use the SDMMC_DataConfig(), SDMMC_GetDataCounter(), - SDMMC_ReadFIFO(), SDMMC_WriteFIFO() and SDMMC_GetFIFOCount() functions. - - *** Read Operations *** - ======================= - [..] - (#) First, user has to fill the data structure (pointer to - SDMMC_DataInitTypeDef) according to the selected data type to be received. - The parameters that should be filled are: - (++) Data TimeOut - (++) Data Length - (++) Data Block size - (++) Data Transfer direction: should be from card (To SDMMC) - (++) Data Transfer mode - (++) DPSM Status (Enable or Disable) - - (#) Configure the SDMMC resources to receive the data from the card - according to selected transfer mode (Refer to Step 8, 9 and 10). - - (#) Send the selected Read command (refer to step 11). - - (#) Use the SDMMC flags/interrupts to check the transfer status. - - *** Write Operations *** - ======================== - [..] - (#) First, user has to fill the data structure (pointer to - SDMMC_DataInitTypeDef) according to the selected data type to be received. - The parameters that should be filled are: - (++) Data TimeOut - (++) Data Length - (++) Data Block size - (++) Data Transfer direction: should be to card (To CARD) - (++) Data Transfer mode - (++) DPSM Status (Enable or Disable) - - (#) Configure the SDMMC resources to send the data to the card according to - selected transfer mode. - - (#) Send the selected Write command. - - (#) Use the SDMMC flags/interrupts to check the transfer status. - - *** Command management operations *** - ===================================== - [..] - (#) The commands used for Read/Write/Erase operations are managed in - separate functions. - Each function allows to send the needed command with the related argument, - then check the response. - By the same approach, you could implement a command and check the response. - - @endverbatim - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "stm32h7xx_hal.h" - -/** @addtogroup STM32H7xx_HAL_Driver - * @{ - */ - -/** @defgroup SDMMC_LL SDMMC Low Layer - * @brief Low layer module for SD - * @{ - */ - -#if defined (SDMMC1) || defined (SDMMC2) -#if defined (HAL_SD_MODULE_ENABLED) || defined (HAL_MMC_MODULE_ENABLED) || defined (HAL_SDIO_MODULE_ENABLED) - -/* Private typedef -----------------------------------------------------------*/ -/* Private define ------------------------------------------------------------*/ -/* Private macro -------------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -/* Private function prototypes -----------------------------------------------*/ -static uint32_t SDMMC_GetCmdError(SDMMC_TypeDef *SDMMCx); - -/* Exported functions --------------------------------------------------------*/ - -/** @defgroup SDMMC_LL_Exported_Functions SDMMC Low Layer Exported Functions - * @{ - */ - -/** @defgroup HAL_SDMMC_LL_Group1 Initialization de-initialization functions - * @brief Initialization and Configuration functions - * -@verbatim - =============================================================================== - ##### Initialization/de-initialization functions ##### - =============================================================================== - [..] This section provides functions allowing to: - -@endverbatim - * @{ - */ - -/** - * @brief Initializes the SDMMC according to the specified - * parameters in the SDMMC_InitTypeDef and create the associated handle. - * @param SDMMCx: Pointer to SDMMC register base - * @param Init: SDMMC initialization structure - * @retval HAL status - */ -HAL_StatusTypeDef SDMMC_Init(SDMMC_TypeDef *SDMMCx, SDMMC_InitTypeDef Init) -{ - uint32_t tmpreg = 0; - - /* Check the parameters */ - assert_param(IS_SDMMC_ALL_INSTANCE(SDMMCx)); - assert_param(IS_SDMMC_CLOCK_EDGE(Init.ClockEdge)); - assert_param(IS_SDMMC_CLOCK_POWER_SAVE(Init.ClockPowerSave)); - assert_param(IS_SDMMC_BUS_WIDE(Init.BusWide)); - assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(Init.HardwareFlowControl)); - assert_param(IS_SDMMC_CLKDIV(Init.ClockDiv)); - - /* Set SDMMC configuration parameters */ - tmpreg |= (Init.ClockEdge | \ - Init.ClockPowerSave | \ - Init.BusWide | \ - Init.HardwareFlowControl | \ - Init.ClockDiv - ); - - /* Write to SDMMC CLKCR */ - MODIFY_REG(SDMMCx->CLKCR, CLKCR_CLEAR_MASK, tmpreg); - - return HAL_OK; -} - - -/** - * @} - */ - -/** @defgroup HAL_SDMMC_LL_Group2 IO operation functions - * @brief Data transfers functions - * -@verbatim - =============================================================================== - ##### I/O operation functions ##### - =============================================================================== - [..] - This subsection provides a set of functions allowing to manage the SDMMC data - transfers. - -@endverbatim - * @{ - */ - -/** - * @brief Read data (word) from Rx FIFO in blocking mode (polling) - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_ReadFIFO(const SDMMC_TypeDef *SDMMCx) -{ - /* Read data from Rx FIFO */ - return (SDMMCx->FIFO); -} - -/** - * @brief Write data (word) to Tx FIFO in blocking mode (polling) - * @param SDMMCx: Pointer to SDMMC register base - * @param pWriteData: pointer to data to write - * @retval HAL status - */ -HAL_StatusTypeDef SDMMC_WriteFIFO(SDMMC_TypeDef *SDMMCx, uint32_t *pWriteData) -{ - /* Write data to FIFO */ - SDMMCx->FIFO = *pWriteData; - - return HAL_OK; -} - -/** - * @} - */ - -/** @defgroup HAL_SDMMC_LL_Group3 Peripheral Control functions - * @brief management functions - * -@verbatim - =============================================================================== - ##### Peripheral Control functions ##### - =============================================================================== - [..] - This subsection provides a set of functions allowing to control the SDMMC data - transfers. - -@endverbatim - * @{ - */ - -/** - * @brief Set SDMMC Power state to ON. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -HAL_StatusTypeDef SDMMC_PowerState_ON(SDMMC_TypeDef *SDMMCx) -{ - /* Set power state to ON */ - SDMMCx->POWER |= SDMMC_POWER_PWRCTRL; - - return HAL_OK; -} - -/** - * @brief Set SDMMC Power state to Power-Cycle. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -HAL_StatusTypeDef SDMMC_PowerState_Cycle(SDMMC_TypeDef *SDMMCx) -{ - /* Set power state to Power Cycle*/ - SDMMCx->POWER |= SDMMC_POWER_PWRCTRL_1; - - return HAL_OK; -} - -/** - * @brief Set SDMMC Power state to OFF. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -HAL_StatusTypeDef SDMMC_PowerState_OFF(SDMMC_TypeDef *SDMMCx) -{ - /* Set power state to OFF */ - SDMMCx->POWER &= ~(SDMMC_POWER_PWRCTRL); - - return HAL_OK; -} - -/** - * @brief Get SDMMC Power state. - * @param SDMMCx: Pointer to SDMMC register base - * @retval Power status of the controller. The returned value can be one of the - * following values: - * - 0x00: Power OFF - * - 0x02: Power UP - * - 0x03: Power ON - */ -uint32_t SDMMC_GetPowerState(const SDMMC_TypeDef *SDMMCx) -{ - return (SDMMCx->POWER & SDMMC_POWER_PWRCTRL); -} - -/** - * @brief Configure the SDMMC command path according to the specified parameters in - * SDMMC_CmdInitTypeDef structure and send the command - * @param SDMMCx: Pointer to SDMMC register base - * @param Command: pointer to a SDMMC_CmdInitTypeDef structure that contains - * the configuration information for the SDMMC command - * @retval HAL status - */ -HAL_StatusTypeDef SDMMC_SendCommand(SDMMC_TypeDef *SDMMCx, const SDMMC_CmdInitTypeDef *Command) -{ - uint32_t tmpreg = 0; - - /* Check the parameters */ - assert_param(IS_SDMMC_CMD_INDEX(Command->CmdIndex)); - assert_param(IS_SDMMC_RESPONSE(Command->Response)); - assert_param(IS_SDMMC_WAIT(Command->WaitForInterrupt)); - assert_param(IS_SDMMC_CPSM(Command->CPSM)); - - /* Set the SDMMC Argument value */ - SDMMCx->ARG = Command->Argument; - - /* Set SDMMC command parameters */ - tmpreg |= (uint32_t)(Command->CmdIndex | \ - Command->Response | \ - Command->WaitForInterrupt | \ - Command->CPSM); - - /* Write to SDMMC CMD register */ - MODIFY_REG(SDMMCx->CMD, CMD_CLEAR_MASK, tmpreg); - - return HAL_OK; -} - -/** - * @brief Return the command index of last command for which response received - * @param SDMMCx: Pointer to SDMMC register base - * @retval Command index of the last command response received - */ -uint8_t SDMMC_GetCommandResponse(const SDMMC_TypeDef *SDMMCx) -{ - return (uint8_t)(SDMMCx->RESPCMD); -} - - -/** - * @brief Return the response received from the card for the last command - * @param SDMMCx: Pointer to SDMMC register base - * @param Response: Specifies the SDMMC response register. - * This parameter can be one of the following values: - * @arg SDMMC_RESP1: Response Register 1 - * @arg SDMMC_RESP2: Response Register 2 - * @arg SDMMC_RESP3: Response Register 3 - * @arg SDMMC_RESP4: Response Register 4 - * @retval The Corresponding response register value - */ -uint32_t SDMMC_GetResponse(const SDMMC_TypeDef *SDMMCx, uint32_t Response) -{ - uint32_t tmp; - - /* Check the parameters */ - assert_param(IS_SDMMC_RESP(Response)); - - /* Get the response */ - tmp = (uint32_t)(&(SDMMCx->RESP1)) + Response; - - return (*(__IO uint32_t *) tmp); -} - -/** - * @brief Configure the SDMMC data path according to the specified - * parameters in the SDMMC_DataInitTypeDef. - * @param SDMMCx: Pointer to SDMMC register base - * @param Data : pointer to a SDMMC_DataInitTypeDef structure - * that contains the configuration information for the SDMMC data. - * @retval HAL status - */ -HAL_StatusTypeDef SDMMC_ConfigData(SDMMC_TypeDef *SDMMCx, const SDMMC_DataInitTypeDef *Data) -{ - uint32_t tmpreg = 0; - - /* Check the parameters */ - assert_param(IS_SDMMC_DATA_LENGTH(Data->DataLength)); - assert_param(IS_SDMMC_BLOCK_SIZE(Data->DataBlockSize)); - assert_param(IS_SDMMC_TRANSFER_DIR(Data->TransferDir)); - assert_param(IS_SDMMC_TRANSFER_MODE(Data->TransferMode)); - assert_param(IS_SDMMC_DPSM(Data->DPSM)); - - /* Set the SDMMC Data TimeOut value */ - SDMMCx->DTIMER = Data->DataTimeOut; - - /* Set the SDMMC DataLength value */ - SDMMCx->DLEN = Data->DataLength; - - /* Set the SDMMC data configuration parameters */ - tmpreg |= (uint32_t)(Data->DataBlockSize | \ - Data->TransferDir | \ - Data->TransferMode | \ - Data->DPSM); - - /* Write to SDMMC DCTRL */ - MODIFY_REG(SDMMCx->DCTRL, DCTRL_CLEAR_MASK, tmpreg); - - return HAL_OK; - -} - -/** - * @brief Returns number of remaining data bytes to be transferred. - * @param SDMMCx: Pointer to SDMMC register base - * @retval Number of remaining data bytes to be transferred - */ -uint32_t SDMMC_GetDataCounter(const SDMMC_TypeDef *SDMMCx) -{ - return (SDMMCx->DCOUNT); -} - -/** - * @brief Get the FIFO data - * @param SDMMCx: Pointer to SDMMC register base - * @retval Data received - */ -uint32_t SDMMC_GetFIFOCount(const SDMMC_TypeDef *SDMMCx) -{ - return (SDMMCx->FIFO); -} - -/** - * @brief Sets one of the two options of inserting read wait interval. - * @param SDMMCx: Pointer to SDMMC register base - * @param SDMMC_ReadWaitMode: SDMMC Read Wait operation mode. - * This parameter can be: - * @arg SDMMC_READ_WAIT_MODE_CLK: Read Wait control by stopping SDMMCCLK - * @arg SDMMC_READ_WAIT_MODE_DATA2: Read Wait control using SDMMC_DATA2 - * @retval None - */ -HAL_StatusTypeDef SDMMC_SetSDMMCReadWaitMode(SDMMC_TypeDef *SDMMCx, uint32_t SDMMC_ReadWaitMode) -{ - /* Check the parameters */ - assert_param(IS_SDMMC_READWAIT_MODE(SDMMC_ReadWaitMode)); - - /* Set SDMMC read wait mode */ - MODIFY_REG(SDMMCx->DCTRL, SDMMC_DCTRL_RWMOD, SDMMC_ReadWaitMode); - - return HAL_OK; -} - -/** - * @} - */ - - -/** @defgroup HAL_SDMMC_LL_Group4 Command management functions - * @brief Data transfers functions - * -@verbatim - =============================================================================== - ##### Commands management functions ##### - =============================================================================== - [..] - This subsection provides a set of functions allowing to manage the needed commands. - -@endverbatim - * @{ - */ - -/** - * @brief Send the Data Block Length command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdBlockLength(SDMMC_TypeDef *SDMMCx, uint32_t BlockSize) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)BlockSize; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SET_BLOCKLEN; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SET_BLOCKLEN, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Data Block number command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdBlockCount(SDMMC_TypeDef *SDMMCx, uint32_t BlockCount) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)BlockCount; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SET_BLOCK_COUNT; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SET_BLOCK_COUNT, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Read Single Block command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdReadSingleBlock(SDMMC_TypeDef *SDMMCx, uint32_t ReadAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)ReadAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_READ_SINGLE_BLOCK; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_READ_SINGLE_BLOCK, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Read Multi Block command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdReadMultiBlock(SDMMC_TypeDef *SDMMCx, uint32_t ReadAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)ReadAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_READ_MULT_BLOCK; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_READ_MULT_BLOCK, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Write Single Block command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdWriteSingleBlock(SDMMC_TypeDef *SDMMCx, uint32_t WriteAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)WriteAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_WRITE_SINGLE_BLOCK; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_WRITE_SINGLE_BLOCK, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Write Multi Block command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdWriteMultiBlock(SDMMC_TypeDef *SDMMCx, uint32_t WriteAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)WriteAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_WRITE_MULT_BLOCK; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_WRITE_MULT_BLOCK, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Start Address Erase command for SD and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdSDEraseStartAdd(SDMMC_TypeDef *SDMMCx, uint32_t StartAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)StartAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SD_ERASE_GRP_START; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SD_ERASE_GRP_START, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the End Address Erase command for SD and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdSDEraseEndAdd(SDMMC_TypeDef *SDMMCx, uint32_t EndAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)EndAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SD_ERASE_GRP_END; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SD_ERASE_GRP_END, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Start Address Erase command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdEraseStartAdd(SDMMC_TypeDef *SDMMCx, uint32_t StartAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)StartAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_ERASE_GRP_START; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_ERASE_GRP_START, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the End Address Erase command and check the response - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdEraseEndAdd(SDMMC_TypeDef *SDMMCx, uint32_t EndAdd) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = (uint32_t)EndAdd; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_ERASE_GRP_END; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_ERASE_GRP_END, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Erase command and check the response - * @param SDMMCx Pointer to SDMMC register base - * @param EraseType Type of erase to be performed - * @retval HAL status - */ -uint32_t SDMMC_CmdErase(SDMMC_TypeDef *SDMMCx, uint32_t EraseType) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Set Block Size for Card */ - sdmmc_cmdinit.Argument = EraseType; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_ERASE; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_ERASE, SDMMC_MAXERASETIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Stop Transfer command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdStopTransfer(SDMMC_TypeDef *SDMMCx) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD12 STOP_TRANSMISSION */ - sdmmc_cmdinit.Argument = 0U; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_STOP_TRANSMISSION; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - - __SDMMC_CMDSTOP_ENABLE(SDMMCx); - __SDMMC_CMDTRANS_DISABLE(SDMMCx); - - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_STOP_TRANSMISSION, SDMMC_STOPTRANSFERTIMEOUT); - - __SDMMC_CMDSTOP_DISABLE(SDMMCx); - - /* Ignore Address Out Of Range Error, Not relevant at end of memory */ - if (errorstate == SDMMC_ERROR_ADDR_OUT_OF_RANGE) - { - errorstate = SDMMC_ERROR_NONE; - } - - return errorstate; -} - -/** - * @brief Send the Select Deselect command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @param addr: Address of the card to be selected - * @retval HAL status - */ -uint32_t SDMMC_CmdSelDesel(SDMMC_TypeDef *SDMMCx, uint32_t Addr) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD7 SDMMC_SEL_DESEL_CARD */ - sdmmc_cmdinit.Argument = (uint32_t)Addr; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SEL_DESEL_CARD; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SEL_DESEL_CARD, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Go Idle State command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdGoIdleState(SDMMC_TypeDef *SDMMCx) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = 0U; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_GO_IDLE_STATE; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_NO; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdError(SDMMCx); - - return errorstate; -} - -/** - * @brief Send the Operating Condition command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdOperCond(SDMMC_TypeDef *SDMMCx) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD8 to verify SD card interface operating condition */ - /* Argument: - [31:12]: Reserved (shall be set to '0') - - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V) - - [7:0]: Check Pattern (recommended 0xAA) */ - /* CMD Response: R7 */ - sdmmc_cmdinit.Argument = SDMMC_CHECK_PATTERN; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_HS_SEND_EXT_CSD; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp7(SDMMCx); - - return errorstate; -} - -/** - * @brief Send the Application command to verify that that the next command - * is an application specific com-mand rather than a standard command - * and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: Command Argument - * @retval HAL status - */ -uint32_t SDMMC_CmdAppCommand(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = (uint32_t)Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_APP_CMD; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - /* If there is a HAL_ERROR, it is a MMC card, else - it is a SD card: SD card 2.0 (voltage range mismatch) - or SD card 1.x */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_APP_CMD, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the command asking the accessed card to send its operating - * condition register (OCR) - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: Command Argument - * @retval HAL status - */ -uint32_t SDMMC_CmdAppOperCommand(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SD_APP_OP_COND; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp3(SDMMCx); - - return errorstate; -} - -/** - * @brief Send the Bus Width command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @param BusWidth: BusWidth - * @retval HAL status - */ -uint32_t SDMMC_CmdBusWidth(SDMMC_TypeDef *SDMMCx, uint32_t BusWidth) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = (uint32_t)BusWidth; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_APP_SD_SET_BUSWIDTH; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_APP_SD_SET_BUSWIDTH, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Send SCR command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdSendSCR(SDMMC_TypeDef *SDMMCx) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD51 SD_APP_SEND_SCR */ - sdmmc_cmdinit.Argument = 0U; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SD_APP_SEND_SCR; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SD_APP_SEND_SCR, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Send CID command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdSendCID(SDMMC_TypeDef *SDMMCx) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD2 ALL_SEND_CID */ - sdmmc_cmdinit.Argument = 0U; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_ALL_SEND_CID; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_LONG; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp2(SDMMCx); - - return errorstate; -} - -/** - * @brief Send the Send CSD command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: Command Argument - * @retval HAL status - */ -uint32_t SDMMC_CmdSendCSD(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD9 SEND_CSD */ - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SEND_CSD; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_LONG; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp2(SDMMCx); - - return errorstate; -} - -/** - * @brief Send the Send CSD command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @param pRCA: Card RCA - * @retval HAL status - */ -uint32_t SDMMC_CmdSetRelAdd(SDMMC_TypeDef *SDMMCx, uint16_t *pRCA) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD3 SD_CMD_SET_REL_ADDR */ - sdmmc_cmdinit.Argument = 0U; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SET_REL_ADDR; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp6(SDMMCx, SDMMC_CMD_SET_REL_ADDR, pRCA); - - return errorstate; -} - -/** - * @brief Send the Set Relative Address command to MMC card (not SD card). - * @param SDMMCx Pointer to SDMMC register base - * @param RCA Card RCA - * @retval HAL status - */ -uint32_t SDMMC_CmdSetRelAddMmc(SDMMC_TypeDef *SDMMCx, uint16_t RCA) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD3 SD_CMD_SET_REL_ADDR */ - sdmmc_cmdinit.Argument = ((uint32_t)RCA << 16U); - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SET_REL_ADDR; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SET_REL_ADDR, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Sleep command to MMC card (not SD card). - * @param SDMMCx Pointer to SDMMC register base - * @param Argument Argument of the command (RCA and Sleep/Awake) - * @retval HAL status - */ -uint32_t SDMMC_CmdSleepMmc(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD5 SDMMC_CMD_MMC_SLEEP_AWAKE */ - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_MMC_SLEEP_AWAKE; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_MMC_SLEEP_AWAKE, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Status command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: Command Argument - * @retval HAL status - */ -uint32_t SDMMC_CmdSendStatus(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SEND_STATUS; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SEND_STATUS, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Status register command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @retval HAL status - */ -uint32_t SDMMC_CmdStatusRegister(SDMMC_TypeDef *SDMMCx) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = 0U; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SD_APP_STATUS; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_SD_APP_STATUS, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Sends host capacity support information and activates the card's - * initialization process. Send SDMMC_CMD_SEND_OP_COND command - * @param SDMMCx: Pointer to SDMMC register base - * @parame Argument: Argument used for the command - * @retval HAL status - */ -uint32_t SDMMC_CmdOpCondition(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SEND_OP_COND; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp3(SDMMCx); - - return errorstate; -} - -/** - * @brief Checks switchable function and switch card function. SDMMC_CMD_HS_SWITCH command - * @param SDMMCx: Pointer to SDMMC register base - * @parame Argument: Argument used for the command - * @retval HAL status - */ -uint32_t SDMMC_CmdSwitch(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD6 to activate SDR50 Mode and Power Limit 1.44W */ - /* CMD Response: R1 */ - sdmmc_cmdinit.Argument = Argument; /* SDMMC_SDR25_SWITCH_PATTERN*/ - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_HS_SWITCH; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_HS_SWITCH, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the command asking the accessed card to send its operating - * condition register (OCR) - * @param None - * @retval HAL status - */ -uint32_t SDMMC_CmdVoltageSwitch(SDMMC_TypeDef *SDMMCx) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = 0x00000000; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_VOLTAGE_SWITCH; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_VOLTAGE_SWITCH, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Send the Send EXT_CSD command and check the response. - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: Command Argument - * @retval HAL status - */ -uint32_t SDMMC_CmdSendEXTCSD(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - /* Send CMD9 SEND_CSD */ - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_HS_SEND_EXT_CSD; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp1(SDMMCx, SDMMC_CMD_HS_SEND_EXT_CSD, SDMMC_CMDTIMEOUT); - - return errorstate; -} - -/** - * @brief Execute a cmd52 to write single byte data and read single byte data if needed - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: SDMMC command argument which is sent to a card as part of a command message - * @param pData: pointer to read response if needed - * @retval SD Card error state - */ -uint32_t SDMMC_SDIO_CmdReadWriteDirect(SDMMC_TypeDef *SDMMCx, uint32_t Argument, uint8_t *pResponse) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SDMMC_RW_DIRECT; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp5(SDMMCx, SDMMC_CMD_SDMMC_RW_DIRECT, pResponse); - - return errorstate; -} - -/** - * @brief Execute a cmd53 to write or read multiple data with a single command - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: SDMMC command argument which is sent to a card as part of a command message - * @retval SD Card error state - */ -uint32_t SDMMC_SDIO_CmdReadWriteExtended(SDMMC_TypeDef *SDMMCx, uint32_t Argument) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SDMMC_RW_EXTENDED; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp5(SDMMCx, SDMMC_CMD_SDMMC_RW_EXTENDED, NULL); - - return errorstate; -} - -/** - * @brief Execute a cmd5 to write or read multiple data with a single command - * @param SDMMCx: Pointer to SDMMC register base - * @param Argument: SDMMC command argument which is sent to a card as part of a command message - * @retval SD Card error state - */ -uint32_t SDMMC_CmdSendOperationcondition(SDMMC_TypeDef *SDMMCx, uint32_t Argument, uint32_t *pResp) -{ - SDMMC_CmdInitTypeDef sdmmc_cmdinit; - uint32_t errorstate; - - sdmmc_cmdinit.Argument = Argument; - sdmmc_cmdinit.CmdIndex = SDMMC_CMD_SDMMC_SEN_OP_COND; - sdmmc_cmdinit.Response = SDMMC_RESPONSE_SHORT; - sdmmc_cmdinit.WaitForInterrupt = SDMMC_WAIT_NO; - sdmmc_cmdinit.CPSM = SDMMC_CPSM_ENABLE; - (void)SDMMC_SendCommand(SDMMCx, &sdmmc_cmdinit); - - /* Check for error conditions */ - errorstate = SDMMC_GetCmdResp4(SDMMCx, pResp); - - return errorstate; -} -/** - * @} - */ - - -/** @defgroup HAL_SDMMC_LL_Group5 Responses management functions - * @brief Responses functions - * -@verbatim - =============================================================================== - ##### Responses management functions ##### - =============================================================================== - [..] - This subsection provides a set of functions allowing to manage the needed responses. - -@endverbatim - * @{ - */ -/** - * @brief Checks for error conditions for R1 response. - * @param hsd: SD handle - * @param SD_CMD: The sent command index - * @retval SD Card error state - */ -uint32_t SDMMC_GetCmdResp1(SDMMC_TypeDef *SDMMCx, uint8_t SD_CMD, uint32_t Timeout) -{ - uint32_t response_r1; - uint32_t sta_reg; - - /* 8 is the number of required instructions cycles for the below loop statement. - The Timeout is expressed in ms */ - uint32_t count = Timeout * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - sta_reg = SDMMCx->STA; - } while (((sta_reg & (SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT | - SDMMC_FLAG_BUSYD0END)) == 0U) || ((sta_reg & SDMMC_FLAG_CMDACT) != 0U)); - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT); - - return SDMMC_ERROR_CMD_RSP_TIMEOUT; - } - else if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL); - - return SDMMC_ERROR_CMD_CRC_FAIL; - } - else - { - /* Nothing to do */ - } - - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - - /* Check response received is of desired command */ - if (SDMMC_GetCommandResponse(SDMMCx) != SD_CMD) - { - return SDMMC_ERROR_CMD_CRC_FAIL; - } - - /* We have received response, retrieve it for analysis */ - response_r1 = SDMMC_GetResponse(SDMMCx, SDMMC_RESP1); - - if ((response_r1 & SDMMC_OCR_ERRORBITS) == SDMMC_ALLZERO) - { - return SDMMC_ERROR_NONE; - } - else if ((response_r1 & SDMMC_OCR_ADDR_OUT_OF_RANGE) == SDMMC_OCR_ADDR_OUT_OF_RANGE) - { - return SDMMC_ERROR_ADDR_OUT_OF_RANGE; - } - else if ((response_r1 & SDMMC_OCR_ADDR_MISALIGNED) == SDMMC_OCR_ADDR_MISALIGNED) - { - return SDMMC_ERROR_ADDR_MISALIGNED; - } - else if ((response_r1 & SDMMC_OCR_BLOCK_LEN_ERR) == SDMMC_OCR_BLOCK_LEN_ERR) - { - return SDMMC_ERROR_BLOCK_LEN_ERR; - } - else if ((response_r1 & SDMMC_OCR_ERASE_SEQ_ERR) == SDMMC_OCR_ERASE_SEQ_ERR) - { - return SDMMC_ERROR_ERASE_SEQ_ERR; - } - else if ((response_r1 & SDMMC_OCR_BAD_ERASE_PARAM) == SDMMC_OCR_BAD_ERASE_PARAM) - { - return SDMMC_ERROR_BAD_ERASE_PARAM; - } - else if ((response_r1 & SDMMC_OCR_WRITE_PROT_VIOLATION) == SDMMC_OCR_WRITE_PROT_VIOLATION) - { - return SDMMC_ERROR_WRITE_PROT_VIOLATION; - } - else if ((response_r1 & SDMMC_OCR_LOCK_UNLOCK_FAILED) == SDMMC_OCR_LOCK_UNLOCK_FAILED) - { - return SDMMC_ERROR_LOCK_UNLOCK_FAILED; - } - else if ((response_r1 & SDMMC_OCR_COM_CRC_FAILED) == SDMMC_OCR_COM_CRC_FAILED) - { - return SDMMC_ERROR_COM_CRC_FAILED; - } - else if ((response_r1 & SDMMC_OCR_ILLEGAL_CMD) == SDMMC_OCR_ILLEGAL_CMD) - { - return SDMMC_ERROR_ILLEGAL_CMD; - } - else if ((response_r1 & SDMMC_OCR_CARD_ECC_FAILED) == SDMMC_OCR_CARD_ECC_FAILED) - { - return SDMMC_ERROR_CARD_ECC_FAILED; - } - else if ((response_r1 & SDMMC_OCR_CC_ERROR) == SDMMC_OCR_CC_ERROR) - { - return SDMMC_ERROR_CC_ERR; - } - else if ((response_r1 & SDMMC_OCR_STREAM_READ_UNDERRUN) == SDMMC_OCR_STREAM_READ_UNDERRUN) - { - return SDMMC_ERROR_STREAM_READ_UNDERRUN; - } - else if ((response_r1 & SDMMC_OCR_STREAM_WRITE_OVERRUN) == SDMMC_OCR_STREAM_WRITE_OVERRUN) - { - return SDMMC_ERROR_STREAM_WRITE_OVERRUN; - } - else if ((response_r1 & SDMMC_OCR_CID_CSD_OVERWRITE) == SDMMC_OCR_CID_CSD_OVERWRITE) - { - return SDMMC_ERROR_CID_CSD_OVERWRITE; - } - else if ((response_r1 & SDMMC_OCR_WP_ERASE_SKIP) == SDMMC_OCR_WP_ERASE_SKIP) - { - return SDMMC_ERROR_WP_ERASE_SKIP; - } - else if ((response_r1 & SDMMC_OCR_CARD_ECC_DISABLED) == SDMMC_OCR_CARD_ECC_DISABLED) - { - return SDMMC_ERROR_CARD_ECC_DISABLED; - } - else if ((response_r1 & SDMMC_OCR_ERASE_RESET) == SDMMC_OCR_ERASE_RESET) - { - return SDMMC_ERROR_ERASE_RESET; - } - else if ((response_r1 & SDMMC_OCR_AKE_SEQ_ERROR) == SDMMC_OCR_AKE_SEQ_ERROR) - { - return SDMMC_ERROR_AKE_SEQ_ERR; - } - else - { - return SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } -} - -/** - * @brief Checks for error conditions for R2 (CID or CSD) response. - * @param hsd: SD handle - * @retval SD Card error state - */ -uint32_t SDMMC_GetCmdResp2(SDMMC_TypeDef *SDMMCx) -{ - uint32_t sta_reg; - /* 8 is the number of required instructions cycles for the below loop statement. - The SDMMC_CMDTIMEOUT is expressed in ms */ - uint32_t count = SDMMC_CMDTIMEOUT * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - sta_reg = SDMMCx->STA; - } while (((sta_reg & (SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT)) == 0U) || - ((sta_reg & SDMMC_FLAG_CMDACT) != 0U)); - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT); - - return SDMMC_ERROR_CMD_RSP_TIMEOUT; - } - else if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL); - - return SDMMC_ERROR_CMD_CRC_FAIL; - } - else - { - /* No error flag set */ - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - } - - return SDMMC_ERROR_NONE; -} - -/** - * @brief Checks for error conditions for R3 (OCR) response. - * @param hsd: SD handle - * @retval SD Card error state - */ -uint32_t SDMMC_GetCmdResp3(SDMMC_TypeDef *SDMMCx) -{ - uint32_t sta_reg; - /* 8 is the number of required instructions cycles for the below loop statement. - The SDMMC_CMDTIMEOUT is expressed in ms */ - uint32_t count = SDMMC_CMDTIMEOUT * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - sta_reg = SDMMCx->STA; - } while (((sta_reg & (SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT)) == 0U) || - ((sta_reg & SDMMC_FLAG_CMDACT) != 0U)); - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT); - - return SDMMC_ERROR_CMD_RSP_TIMEOUT; - } - else - { - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - } - - return SDMMC_ERROR_NONE; -} - -/** - * @brief Checks for error conditions for R4 response. - * @param SDMMCx: Pointer to SDMMC register base - * @param pResp: pointer to response - * @retval error state - */ -uint32_t SDMMC_GetCmdResp4(SDMMC_TypeDef *SDMMCx, uint32_t *pResp) -{ - uint32_t sta_reg; - - /* 8 is the number of required instructions cycles for the below loop statement. - The SDMMC_CMDTIMEOUT is expressed in ms */ - uint32_t count = SDMMC_CMDTIMEOUT * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - sta_reg = SDMMCx->STA; - } while (((sta_reg & (SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT)) == 0U) || - ((sta_reg & SDMMC_FLAG_CMDACT) != 0U)); - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT); - - return SDMMC_ERROR_CMD_RSP_TIMEOUT; - } - else - { - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - } - - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - - /* We have received response, retrieve it. */ - *pResp = SDMMC_GetResponse(SDMMCx, SDMMC_RESP1); - - return SDMMC_ERROR_NONE; -} - -/** - * @brief Checks for error conditions for R5 (cmd52/cmd53) response. - * @param SDMMCx: Pointer to SDMMC register base - * @param SDIO_CMD: The sent command index - * @param pData: pointer to the read/write buffer needed for cmd52 - * @retval SDIO Card error state - */ -uint32_t SDMMC_GetCmdResp5(SDMMC_TypeDef *SDMMCx, uint8_t SDIO_CMD, uint8_t *pData) -{ - uint32_t response_r5; - uint32_t sta_reg; - - /* 8 is the number of required instructions cycles for the below loop statement. - The SDMMC_CMDTIMEOUT is expressed in ms */ - uint32_t count = SDMMC_CMDTIMEOUT * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - sta_reg = SDMMCx->STA; - } while (((sta_reg & (SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT)) == 0U) || - ((sta_reg & SDMMC_FLAG_CMDACT) != 0U)); - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT); - - return SDMMC_ERROR_CMD_RSP_TIMEOUT; - } - else if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL); - - return SDMMC_ERROR_CMD_CRC_FAIL; - } - else - { - /* Nothing to do */ - } - - /* Check response received is of desired command */ - if (SDMMC_GetCommandResponse(SDMMCx) != SDIO_CMD) - { - return SDMMC_ERROR_CMD_CRC_FAIL; - } - - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - - /* We have received response, retrieve it. */ - response_r5 = SDMMC_GetResponse(SDMMCx, SDMMC_RESP1); - - if ((response_r5 & SDMMC_SDIO_R5_ERRORBITS) == SDMMC_ALLZERO) - { - /* we only want 8 bit read or write data and the 8 bit response flags are masked in the data pointer */ - if (pData != NULL) - { - *pData = (uint8_t)(response_r5 & 0xFFU); - } - - return SDMMC_ERROR_NONE; - } - else if ((response_r5 & SDMMC_SDIO_R5_OUT_OF_RANGE) == SDMMC_SDIO_R5_OUT_OF_RANGE) - { - return SDMMC_ERROR_ADDR_OUT_OF_RANGE; - } - else if ((response_r5 & SDMMC_SDIO_R5_INVALID_FUNCTION_NUMBER) == SDMMC_SDIO_R5_INVALID_FUNCTION_NUMBER) - { - return SDMMC_ERROR_INVALID_PARAMETER; - } - else if ((response_r5 & SDMMC_SDIO_R5_ILLEGAL_CMD) == SDMMC_SDIO_R5_ILLEGAL_CMD) - { - return SDMMC_ERROR_ILLEGAL_CMD; - } - else if ((response_r5 & SDMMC_SDIO_R5_COM_CRC_FAILED) == SDMMC_SDIO_R5_COM_CRC_FAILED) - { - return SDMMC_ERROR_COM_CRC_FAILED; - } - else - { - return SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } -} - -/** - * @brief Checks for error conditions for R6 (RCA) response. - * @param hsd: SD handle - * @param SD_CMD: The sent command index - * @param pRCA: Pointer to the variable that will contain the SD card relative - * address RCA - * @retval SD Card error state - */ -uint32_t SDMMC_GetCmdResp6(SDMMC_TypeDef *SDMMCx, uint8_t SD_CMD, uint16_t *pRCA) -{ - uint32_t response_r1; - uint32_t sta_reg; - - /* 8 is the number of required instructions cycles for the below loop statement. - The SDMMC_CMDTIMEOUT is expressed in ms */ - uint32_t count = SDMMC_CMDTIMEOUT * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - sta_reg = SDMMCx->STA; - } while (((sta_reg & (SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT)) == 0U) || - ((sta_reg & SDMMC_FLAG_CMDACT) != 0U)); - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT); - - return SDMMC_ERROR_CMD_RSP_TIMEOUT; - } - else if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL)) - { - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL); - - return SDMMC_ERROR_CMD_CRC_FAIL; - } - else - { - /* Nothing to do */ - } - - /* Check response received is of desired command */ - if (SDMMC_GetCommandResponse(SDMMCx) != SD_CMD) - { - return SDMMC_ERROR_CMD_CRC_FAIL; - } - - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - - /* We have received response, retrieve it. */ - response_r1 = SDMMC_GetResponse(SDMMCx, SDMMC_RESP1); - - if ((response_r1 & (SDMMC_R6_GENERAL_UNKNOWN_ERROR | SDMMC_R6_ILLEGAL_CMD | - SDMMC_R6_COM_CRC_FAILED)) == SDMMC_ALLZERO) - { - *pRCA = (uint16_t)(response_r1 >> 16); - - return SDMMC_ERROR_NONE; - } - else if ((response_r1 & SDMMC_R6_ILLEGAL_CMD) == SDMMC_R6_ILLEGAL_CMD) - { - return SDMMC_ERROR_ILLEGAL_CMD; - } - else if ((response_r1 & SDMMC_R6_COM_CRC_FAILED) == SDMMC_R6_COM_CRC_FAILED) - { - return SDMMC_ERROR_COM_CRC_FAILED; - } - else - { - return SDMMC_ERROR_GENERAL_UNKNOWN_ERR; - } -} - -/** - * @brief Checks for error conditions for R7 response. - * @param hsd: SD handle - * @retval SD Card error state - */ -uint32_t SDMMC_GetCmdResp7(SDMMC_TypeDef *SDMMCx) -{ - uint32_t sta_reg; - /* 8 is the number of required instructions cycles for the below loop statement. - The SDMMC_CMDTIMEOUT is expressed in ms */ - uint32_t count = SDMMC_CMDTIMEOUT * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - sta_reg = SDMMCx->STA; - } while (((sta_reg & (SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT)) == 0U) || - ((sta_reg & SDMMC_FLAG_CMDACT) != 0U)); - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)) - { - /* Card is not SD V2.0 compliant */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT); - - return SDMMC_ERROR_CMD_RSP_TIMEOUT; - } - - else if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL)) - { - /* Card is not SD V2.0 compliant */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL); - - return SDMMC_ERROR_CMD_CRC_FAIL; - } - else - { - /* Nothing to do */ - } - - if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CMDREND)) - { - /* Card is SD V2.0 compliant */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CMDREND); - } - - return SDMMC_ERROR_NONE; - -} - -/** - * @} - */ - -/* Private function ----------------------------------------------------------*/ -/** @addtogroup SD_Private_Functions - * @{ - */ - -/** - * @brief Checks for error conditions for CMD0. - * @param hsd: SD handle - * @retval SD Card error state - */ -static uint32_t SDMMC_GetCmdError(SDMMC_TypeDef *SDMMCx) -{ - /* 8 is the number of required instructions cycles for the below loop statement. - The SDMMC_CMDTIMEOUT is expressed in ms */ - uint32_t count = SDMMC_CMDTIMEOUT * (SystemCoreClock / 8U / 1000U); - - do - { - if (count-- == 0U) - { - return SDMMC_ERROR_TIMEOUT; - } - - } while (!__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CMDSENT)); - - /* Clear all the static flags */ - __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS); - - return SDMMC_ERROR_NONE; -} - -/** - * @} - */ - -#endif /* HAL_SD_MODULE_ENABLED || HAL_MMC_MODULE_ENABLED */ -#endif /* SDMMC1 || SDMMC2 */ -/** - * @} - */ - -/** - * @} - */ diff --git a/Software/FT23_Charger.ioc b/Software/FT23_Charger.ioc index 5de4ae5..c97567b 100644 --- a/Software/FT23_Charger.ioc +++ b/Software/FT23_Charger.ioc @@ -2,9 +2,9 @@ CAD.formats= CAD.pinconfig= CAD.provider= -FDCAN1.CalculateBaudRateNominal=500000 -FDCAN1.CalculateTimeBitNominal=2000 -FDCAN1.CalculateTimeQuantumNominal=25.0 +FDCAN1.CalculateBaudRateNominal=875000 +FDCAN1.CalculateTimeBitNominal=1142 +FDCAN1.CalculateTimeQuantumNominal=14.285714285714286 FDCAN1.IPParameters=CalculateTimeQuantumNominal,CalculateTimeBitNominal,CalculateBaudRateNominal,StdFiltersNbr,RxFifo0ElmtsNbr,TxFifoQueueElmtsNbr,NominalPrescaler,NominalTimeSeg1,NominalTimeSeg2 FDCAN1.NominalPrescaler=2 FDCAN1.NominalTimeSeg1=63 @@ -14,26 +14,25 @@ FDCAN1.StdFiltersNbr=32 FDCAN1.TxFifoQueueElmtsNbr=1 FMC.CASLatency1=FMC_SDRAM_CAS_LATENCY_3 FMC.ColumnBitsNumber1=FMC_SDRAM_COLUMN_BITS_NUM_9 -FMC.ExitSelfRefreshDelay1=5 -FMC.IPParameters=ReadBurst1,WriteProtection1,LoadToActiveDelay1,ExitSelfRefreshDelay1,CASLatency1,SelfRefreshTime1,RowCycleDelay1,RowCycleDelay2,RCDDelay1,RPDelay1,RPDelay2,WriteRecoveryTime1,ColumnBitsNumber1,ReadPipeDelay1,ReadPipeDelay2,SDClockPeriod1,SDClockPeriod2 +FMC.ExitSelfRefreshDelay1=10 +FMC.IPParameters=ReadBurst1,WriteProtection1,LoadToActiveDelay1,ExitSelfRefreshDelay1,CASLatency1,SelfRefreshTime1,RowCycleDelay1,RowCycleDelay2,RCDDelay1,RPDelay1,RPDelay2,ColumnBitsNumber1,ReadPipeDelay1,SDClockPeriod1,WriteRecoveryTime1,ReadPipeDelay2 FMC.LoadToActiveDelay1=2 FMC.RCDDelay1=2 -FMC.RPDelay1=3 -FMC.RPDelay2=3 +FMC.RPDelay1=2 +FMC.RPDelay2=2 FMC.ReadBurst1=FMC_SDRAM_RBURST_DISABLE FMC.ReadPipeDelay1=FMC_SDRAM_RPIPE_DELAY_1 FMC.ReadPipeDelay2=FMC_SDRAM_RPIPE_DELAY_1 -FMC.RowCycleDelay1=4 -FMC.RowCycleDelay2=4 -FMC.SDClockPeriod1=FMC_SDRAM_CLOCK_PERIOD_2 -FMC.SDClockPeriod2=FMC_SDRAM_CLOCK_PERIOD_2 -FMC.SelfRefreshTime1=3 +FMC.RowCycleDelay1=8 +FMC.RowCycleDelay2=8 +FMC.SDClockPeriod1=FMC_SDRAM_CLOCK_DISABLE +FMC.SelfRefreshTime1=6 FMC.WriteProtection1=FMC_SDRAM_WRITE_PROTECTION_DISABLE -FMC.WriteRecoveryTime1=3 +FMC.WriteRecoveryTime1=4 File.Version=6 GPIO.groupedBy=Group By Peripherals I2C4.IPParameters=Timing -I2C4.Timing=0x10909CEC +I2C4.Timing=0x20B0CCFF KeepUserPlacement=false LTDC.ActiveH=272 LTDC.ActiveW=480 @@ -43,11 +42,12 @@ LTDC.FBStartAdress_L0=201326592 LTDC.HBP=50 LTDC.HFP=50 LTDC.HSync=20 -LTDC.IPParameters=ActiveW,ActiveH,HFP,HBP,HSync,VSync,VBP,VFP,Layers,FBStartAdress_L0,ImageWidth_L0,ImageHeight_L0,PixelFormat_L0,Blue_L0,WindowX0_L0,WindowX1_L0,WindowY0_L0,WindowY1_L0,Alpha_L0 +LTDC.IPParameters=ActiveW,ActiveH,HFP,HBP,HSync,VSync,VBP,VFP,Layers,FBStartAdress_L0,ImageWidth_L0,ImageHeight_L0,PixelFormat_L0,Blue_L0,WindowX0_L0,WindowX1_L0,WindowY0_L0,WindowY1_L0,Alpha_L0,Red LTDC.ImageHeight_L0=600 LTDC.ImageWidth_L0=1024 LTDC.Layers=0 -LTDC.PixelFormat_L0=LTDC_PIXEL_FORMAT_RGB565 +LTDC.PixelFormat_L0=LTDC_PIXEL_FORMAT_RGB888 +LTDC.Red=255 LTDC.VBP=20 LTDC.VFP=12 LTDC.VSync=3 @@ -61,11 +61,10 @@ Mcu.CPN=STM32H7A3ZIT6 Mcu.Family=STM32H7 Mcu.IP0=CORTEX_M7 Mcu.IP1=CRC -Mcu.IP10=SDMMC2 -Mcu.IP11=SYS -Mcu.IP12=UART5 -Mcu.IP13=USART10 -Mcu.IP14=USB_OTG_HS +Mcu.IP10=SYS +Mcu.IP11=UART5 +Mcu.IP12=USART10 +Mcu.IP13=USB_OTG_HS Mcu.IP2=DEBUG Mcu.IP3=FDCAN1 Mcu.IP4=FMC @@ -74,7 +73,7 @@ Mcu.IP6=LTDC Mcu.IP7=MEMORYMAP Mcu.IP8=NVIC Mcu.IP9=RCC -Mcu.IPNb=15 +Mcu.IPNb=14 Mcu.Name=STM32H7A3Z(G-I)Tx Mcu.Package=LQFP144 Mcu.Pin0=PE2 @@ -85,9 +84,9 @@ Mcu.Pin12=PF10 Mcu.Pin13=PH0-OSC_IN Mcu.Pin14=PH1-OSC_OUT Mcu.Pin15=PC0 -Mcu.Pin16=PC1 -Mcu.Pin17=PC2_C -Mcu.Pin18=PC3_C +Mcu.Pin16=PC2_C +Mcu.Pin17=PC3_C +Mcu.Pin18=PA1 Mcu.Pin19=PA3 Mcu.Pin2=PC14-OSC32_IN Mcu.Pin20=PA4 @@ -119,61 +118,60 @@ Mcu.Pin43=PB10 Mcu.Pin44=PB11 Mcu.Pin45=PB12 Mcu.Pin46=PB13 -Mcu.Pin47=PB14 -Mcu.Pin48=PB15 -Mcu.Pin49=PD8 +Mcu.Pin47=PB15 +Mcu.Pin48=PD8 +Mcu.Pin49=PD9 Mcu.Pin5=PF1 -Mcu.Pin50=PD9 -Mcu.Pin51=PD10 -Mcu.Pin52=PD14 -Mcu.Pin53=PD15 -Mcu.Pin54=PG2 -Mcu.Pin55=PG4 -Mcu.Pin56=PG5 -Mcu.Pin57=PG7 -Mcu.Pin58=PG8 -Mcu.Pin59=PC6 +Mcu.Pin50=PD10 +Mcu.Pin51=PD14 +Mcu.Pin52=PD15 +Mcu.Pin53=PG2 +Mcu.Pin54=PG4 +Mcu.Pin55=PG5 +Mcu.Pin56=PG7 +Mcu.Pin57=PG8 +Mcu.Pin58=PC6 +Mcu.Pin59=PC7 Mcu.Pin6=PF2 -Mcu.Pin60=PC7 -Mcu.Pin61=PC8 -Mcu.Pin62=PC9 -Mcu.Pin63=PA8 -Mcu.Pin64=PA9 -Mcu.Pin65=PA10 -Mcu.Pin66=PA11 -Mcu.Pin67=PA12 -Mcu.Pin68=PA13 -Mcu.Pin69=PA14 +Mcu.Pin60=PC8 +Mcu.Pin61=PC9 +Mcu.Pin62=PA8 +Mcu.Pin63=PA9 +Mcu.Pin64=PA10 +Mcu.Pin65=PA11 +Mcu.Pin66=PA12 +Mcu.Pin67=PA13 +Mcu.Pin68=PA14 +Mcu.Pin69=PA15 Mcu.Pin7=PF3 -Mcu.Pin70=PA15 -Mcu.Pin71=PC10 -Mcu.Pin72=PC11 -Mcu.Pin73=PC12 -Mcu.Pin74=PD0 -Mcu.Pin75=PD1 -Mcu.Pin76=PD2 -Mcu.Pin77=PD7 -Mcu.Pin78=PG9 -Mcu.Pin79=PG11 +Mcu.Pin70=PC10 +Mcu.Pin71=PC11 +Mcu.Pin72=PC12 +Mcu.Pin73=PD0 +Mcu.Pin74=PD1 +Mcu.Pin75=PD2 +Mcu.Pin76=PD6 +Mcu.Pin77=PG9 +Mcu.Pin78=PG11 +Mcu.Pin79=PG12 Mcu.Pin8=PF4 -Mcu.Pin80=PG12 -Mcu.Pin81=PG13 -Mcu.Pin82=PG14 -Mcu.Pin83=PG15 -Mcu.Pin84=PB3 -Mcu.Pin85=PB4 -Mcu.Pin86=PB5 -Mcu.Pin87=PB6 -Mcu.Pin88=PB7 -Mcu.Pin89=PB8 +Mcu.Pin80=PG13 +Mcu.Pin81=PG14 +Mcu.Pin82=PG15 +Mcu.Pin83=PB3 +Mcu.Pin84=PB4 +Mcu.Pin85=PB5 +Mcu.Pin86=PB6 +Mcu.Pin87=PB7 +Mcu.Pin88=PB8 +Mcu.Pin89=PB9 Mcu.Pin9=PF5 -Mcu.Pin90=PB9 -Mcu.Pin91=PE0 -Mcu.Pin92=PE1 -Mcu.Pin93=VP_CRC_VS_CRC -Mcu.Pin94=VP_SYS_VS_Systick -Mcu.Pin95=VP_MEMORYMAP_VS_MEMORYMAP -Mcu.PinsNb=96 +Mcu.Pin90=PE0 +Mcu.Pin91=PE1 +Mcu.Pin92=VP_CRC_VS_CRC +Mcu.Pin93=VP_SYS_VS_Systick +Mcu.Pin94=VP_MEMORYMAP_VS_MEMORYMAP +Mcu.PinsNb=95 Mcu.ThirdParty0=STMicroelectronics.X-CUBE-TOUCHGFX.4.21.0 Mcu.ThirdPartyNb=1 Mcu.UserConstants= @@ -196,7 +194,9 @@ NVIC.PriorityGroup=NVIC_PRIORITYGROUP_4 NVIC.SVCall_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false NVIC.SysTick_IRQn=true\:0\:0\:false\:false\:true\:false\:true\:false NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false -PA10.Mode=RGB565 +PA1.Mode=RGB666 +PA1.Signal=LTDC_R2 +PA10.Mode=RGB666 PA10.Signal=LTDC_B4 PA11.Mode=Device_Only_FS PA11.Signal=USB_OTG_HS_DM @@ -206,36 +206,34 @@ PA13.Mode=Trace_Asynchronous_SW PA13.Signal=DEBUG_JTMS-SWDIO PA14.Mode=Trace_Asynchronous_SW PA14.Signal=DEBUG_JTCK-SWCLK -PA15.Mode=RGB565 +PA15.Mode=RGB666 PA15.Signal=LTDC_B6 -PA3.Mode=RGB565 +PA3.Mode=RGB666 PA3.Signal=LTDC_B5 -PA4.Mode=RGB565 +PA4.Mode=RGB666 PA4.Signal=LTDC_VSYNC -PA5.Mode=RGB565 +PA5.Mode=RGB666 PA5.Signal=LTDC_R4 -PA6.Mode=RGB565 +PA6.Mode=RGB666 PA6.Signal=LTDC_G2 PA7.Signal=FMC_SDNWE -PA8.Mode=RGB565 +PA8.Mode=RGB666 PA8.Signal=LTDC_B3 PA9.Mode=Activate_VBUS_FS PA9.Signal=USB_OTG_HS_VBUS -PB0.Mode=RGB565 +PB0.Mode=RGB666 PB0.Signal=LTDC_R3 -PB1.Mode=RGB565 +PB1.Mode=RGB666 PB1.Signal=LTDC_R6 -PB10.Mode=RGB565 +PB10.Mode=RGB666 PB10.Signal=LTDC_G4 -PB11.Mode=RGB565 +PB11.Mode=RGB666 PB11.Signal=LTDC_G5 PB12.Mode=Asynchronous PB12.Signal=UART5_RX PB13.Mode=Asynchronous PB13.Signal=UART5_TX -PB14.Mode=SD_1_bit -PB14.Signal=SDMMC2_D0 -PB15.Mode=RGB565 +PB15.Mode=RGB666 PB15.Signal=LTDC_G7 PB3.Mode=Trace_Asynchronous_SW PB3.Signal=DEBUG_JTDO-SWO @@ -261,10 +259,8 @@ PB8.Mode=FDCAN_Activate PB8.Signal=FDCAN1_RX PB9.Mode=FDCAN_Activate PB9.Signal=FDCAN1_TX -PC0.Mode=RGB565 +PC0.Mode=RGB666 PC0.Signal=LTDC_R5 -PC1.Mode=SD_1_bit -PC1.Signal=SDMMC2_CK PC10.GPIOParameters=GPIO_Label PC10.GPIO_Label=Display_Standby PC10.Locked=true @@ -285,27 +281,27 @@ PC2_C.Mode=SdramChipSelect1_1 PC2_C.Signal=FMC_SDNE0 PC3_C.Mode=SdramChipSelect1_1 PC3_C.Signal=FMC_SDCKE0 -PC4.Mode=RGB565 +PC4.Mode=RGB666 PC4.Signal=LTDC_R7 -PC6.Mode=RGB565 +PC6.Mode=RGB666 PC6.Signal=LTDC_HSYNC -PC7.Mode=RGB565 +PC7.Mode=RGB666 PC7.Signal=LTDC_G6 PC8.GPIOParameters=GPIO_Label PC8.GPIO_Label=Display_Reset PC8.Locked=true PC8.Signal=GPIO_Output -PC9.Mode=RGB565 +PC9.Mode=RGB666 PC9.Signal=LTDC_G3 PD0.Signal=FMC_D2_DA2 PD1.Signal=FMC_D3_DA3 PD10.Signal=FMC_D15_DA15 PD14.Signal=FMC_D0_DA0 PD15.Signal=FMC_D1_DA1 -PD2.Mode=RGB565 +PD2.Mode=RGB666 PD2.Signal=LTDC_B7 -PD7.Mode=SD_1_bit -PD7.Signal=SDMMC2_CMD +PD6.Mode=RGB666 +PD6.Signal=LTDC_B2 PD8.Signal=FMC_D13_DA13 PD9.Signal=FMC_D14_DA14 PE0.Signal=FMC_NBL0 @@ -327,7 +323,7 @@ PE8.Signal=FMC_D5_DA5 PE9.Signal=FMC_D6_DA6 PF0.Signal=FMC_A0 PF1.Signal=FMC_A1 -PF10.Mode=RGB565 +PF10.Mode=RGB666 PF10.Signal=LTDC_DE PF11.Signal=FMC_SDNRAS PF12.Signal=FMC_A6 @@ -368,7 +364,7 @@ PG15.Signal=FMC_SDNCAS PG2.Signal=FMC_A12 PG4.Signal=FMC_A14_BA0 PG5.Signal=FMC_A15_BA1 -PG7.Mode=RGB565 +PG7.Mode=RGB666 PG7.Signal=LTDC_CLK PG8.Signal=FMC_SDCLK PG9.GPIOParameters=GPIO_Label @@ -410,18 +406,17 @@ ProjectManager.ToolChainLocation= ProjectManager.UAScriptAfterPath= ProjectManager.UAScriptBeforePath= ProjectManager.UnderRoot=false -ProjectManager.functionlistsort=1-MX_GPIO_Init-GPIO-false-HAL-true,2-SystemClock_Config-RCC-false-HAL-false,3-MX_FDCAN1_Init-FDCAN1-false-HAL-true,4-MX_FMC_Init-FMC-false-HAL-true,5-MX_I2C4_Init-I2C4-false-HAL-true,6-MX_SDMMC2_SD_Init-SDMMC2-false-HAL-true,7-MX_USART10_UART_Init-USART10-false-HAL-true,8-MX_USB_OTG_HS_PCD_Init-USB_OTG_HS-false-HAL-true,9-MX_UART5_Init-UART5-false-HAL-true,10-MX_LTDC_Init-LTDC-false-HAL-true,11-MX_CRC_Init-CRC-false-HAL-true,13-MX_TouchGFX_Init-STMicroelectronics.X-CUBE-TOUCHGFX.4.21.0-false-HAL-false,0-MX_CORTEX_M7_Init-CORTEX_M7-false-HAL-true,14-MX_TouchGFX_Process-STMicroelectronics.X-CUBE-TOUCHGFX.4.21.0-false-HAL-false +ProjectManager.functionlistsort=1-MX_GPIO_Init-GPIO-false-HAL-true,2-SystemClock_Config-RCC-false-HAL-false,3-MX_FDCAN1_Init-FDCAN1-false-HAL-true,4-MX_FMC_Init-FMC-false-HAL-true,5-MX_I2C4_Init-I2C4-false-HAL-true,6-MX_SDMMC2_SD_Init-SDMMC2-false-HAL-true,6-MX_USART10_UART_Init-USART10-false-HAL-true,7-MX_USB_OTG_HS_PCD_Init-USB_OTG_HS-false-HAL-true,8-MX_UART5_Init-UART5-false-HAL-true,9-MX_LTDC_Init-LTDC-false-HAL-true,10-MX_CRC_Init-CRC-false-HAL-true,0-MX_CORTEX_M7_Init-CORTEX_M7-false-HAL-true RCC.ADCCLockSelection=RCC_ADCCLKSOURCE_PLL2 -RCC.ADCFreq_Value=160000000 -RCC.AHB12Freq_Value=160000000 -RCC.AHB4Freq_Value=160000000 -RCC.APB1Freq_Value=80000000 -RCC.APB2Freq_Value=80000000 -RCC.APB3Freq_Value=80000000 -RCC.APB4Freq_Value=80000000 -RCC.AXIClockFreq_Value=160000000 -RCC.CDCPRE=RCC_SYSCLK_DIV1 -RCC.CDCPREFreq_Value=160000000 +RCC.ADCFreq_Value=280000000 +RCC.AHB12Freq_Value=280000000 +RCC.AHB4Freq_Value=280000000 +RCC.APB1Freq_Value=140000000 +RCC.APB2Freq_Value=140000000 +RCC.APB3Freq_Value=140000000 +RCC.APB4Freq_Value=140000000 +RCC.AXIClockFreq_Value=280000000 +RCC.CDCPREFreq_Value=280000000 RCC.CDPPRE=RCC_APB3_DIV2 RCC.CDPPRE1=RCC_APB1_DIV2 RCC.CDPPRE2=RCC_APB2_DIV2 @@ -430,75 +425,74 @@ RCC.CECFreq_Value=32000 RCC.CKPERFreq_Value=64000000 RCC.CKPERSourceSelection=RCC_CLKPSOURCE_HSI RCC.CSI_VALUE=4000000 -RCC.CortexFreq_Value=160000000 +RCC.CortexFreq_Value=280000000 RCC.Cortex_Div=SYSTICK_CLKSOURCE_HCLK RCC.Cortex_DivARG=SystemCoreClock/1000 -RCC.CpuClockFreq_Value=160000000 +RCC.CpuClockFreq_Value=280000000 RCC.DAC1Freq_Value=32000 RCC.DAC2Freq_Value=32000 -RCC.DFSDM2ACLkFreq_Value=80000000 -RCC.DFSDM2Freq_Value=80000000 -RCC.DFSDMACLkFreq_Value=80000000 +RCC.DFSDM2ACLkFreq_Value=140000000 +RCC.DFSDM2Freq_Value=140000000 +RCC.DFSDMACLkFreq_Value=140000000 RCC.DFSDMCLockSelection=RCC_DFSDM1CLKSOURCE_D2PCLK1 -RCC.DFSDMFreq_Value=80000000 -RCC.DIVM1=1 -RCC.DIVM2=1 +RCC.DFSDMFreq_Value=140000000 +RCC.DIVM1=2 +RCC.DIVM2=2 RCC.DIVM3=1 -RCC.DIVN1=20 -RCC.DIVN2=20 +RCC.DIVN1=70 +RCC.DIVN2=70 RCC.DIVN3=12 -RCC.DIVP1=2 -RCC.DIVP1Freq_Value=160000000 +RCC.DIVP1Freq_Value=280000000 RCC.DIVP2=2 -RCC.DIVP2Freq_Value=160000000 +RCC.DIVP2Freq_Value=280000000 RCC.DIVP3=2 RCC.DIVP3Freq_Value=96000000 RCC.DIVQ1=4 -RCC.DIVQ1Freq_Value=80000000 +RCC.DIVQ1Freq_Value=140000000 RCC.DIVQ2=4 -RCC.DIVQ2Freq_Value=80000000 +RCC.DIVQ2Freq_Value=140000000 RCC.DIVQ3=3 RCC.DIVQ3Freq_Value=64000000 -RCC.DIVR1=2 -RCC.DIVR1Freq_Value=160000000 -RCC.DIVR2Freq_Value=160000000 +RCC.DIVR1=4 +RCC.DIVR1Freq_Value=140000000 +RCC.DIVR2Freq_Value=280000000 RCC.DIVR3=3 RCC.DIVR3Freq_Value=64000000 RCC.EXTERNAL_CLOCK_VALUE=12288000 -RCC.FDCANFreq_Value=80000000 +RCC.FDCANFreq_Value=140000000 RCC.FMCCLockSelection=RCC_FMCCLKSOURCE_PLL2 -RCC.FMCFreq_Value=160000000 +RCC.FMCFreq_Value=280000000 RCC.FamilyName=M -RCC.HCLK3ClockFreq_Value=160000000 -RCC.HCLKFreq_Value=160000000 +RCC.HCLK3ClockFreq_Value=280000000 +RCC.HCLKFreq_Value=280000000 RCC.HPRE=RCC_HCLK_DIV1 RCC.HSE_VALUE=16000000 RCC.HSI48_VALUE=48000000 RCC.HSIDiv=RCC_PLLSAIDIVR_1 RCC.HSI_VALUE=64000000 RCC.I2C123CLockSelection=RCC_I2C123CLKSOURCE_D2PCLK1 -RCC.I2C123Freq_Value=80000000 +RCC.I2C123Freq_Value=140000000 RCC.I2C4CLockSelection=RCC_I2C4CLKSOURCE_D3PCLK1 -RCC.I2C4Freq_Value=80000000 -RCC.IPParameters=ADCCLockSelection,ADCFreq_Value,AHB12Freq_Value,AHB4Freq_Value,APB1Freq_Value,APB2Freq_Value,APB3Freq_Value,APB4Freq_Value,AXIClockFreq_Value,CDCPRE,CDCPREFreq_Value,CDPPRE,CDPPRE1,CDPPRE2,CECCLockSelection,CECFreq_Value,CKPERFreq_Value,CKPERSourceSelection,CSI_VALUE,CortexFreq_Value,Cortex_Div,Cortex_DivARG,CpuClockFreq_Value,DAC1Freq_Value,DAC2Freq_Value,DFSDM2ACLkFreq_Value,DFSDM2Freq_Value,DFSDMACLkFreq_Value,DFSDMCLockSelection,DFSDMFreq_Value,DIVM1,DIVM2,DIVM3,DIVN1,DIVN2,DIVN3,DIVP1,DIVP1Freq_Value,DIVP2,DIVP2Freq_Value,DIVP3,DIVP3Freq_Value,DIVQ1,DIVQ1Freq_Value,DIVQ2,DIVQ2Freq_Value,DIVQ3,DIVQ3Freq_Value,DIVR1,DIVR1Freq_Value,DIVR2Freq_Value,DIVR3,DIVR3Freq_Value,EXTERNAL_CLOCK_VALUE,FDCANFreq_Value,FMCCLockSelection,FMCFreq_Value,FamilyName,HCLK3ClockFreq_Value,HCLKFreq_Value,HPRE,HSE_VALUE,HSI48_VALUE,HSIDiv,HSI_VALUE,I2C123CLockSelection,I2C123Freq_Value,I2C4CLockSelection,I2C4Freq_Value,LPTIM1CLockSelection,LPTIM1Freq_Value,LPTIM2CLockSelection,LPTIM2Freq_Value,LPTIM345CLockSelection,LPTIM345Freq_Value,LPUART1CLockSelection,LPUART1Freq_Value,LSI_VALUE,LTDCFreq_Value,MCO1PinFreq_Value,MCO2PinFreq_Value,PLL2FRACN,PLL3FRACN,PLLFRACN,PLLSourceVirtual,QSPICLockSelection,QSPIFreq_Value,RCC_MCO1Source,RCC_MCO2Source,RCC_MCODiv1,RCC_MCODiv2,RCC_RTC_Clock_Source_FROM_HSE,RNGCLockSelection,RNGFreq_Value,RTCFreq_Value,SAI1CLockSelection,SAI1Freq_Value,SAI2AFreq_Value,SAI2BCLockSelection,SAI2BFreq_Value,SDMMC1CLockSelection,SDMMCFreq_Value,SPDIFCLockSelection,SPDIFRXFreq_Value,SPI123CLockSelection,SPI123Freq_Value,SPI45Freq_Value,SPI6CLockSelection,SPI6Freq_Value,SRDPPRE,SWPCLockSelection,SWPMI1Freq_Value,SYSCLKFreq_VALUE,SYSCLKSource,Spi45ClockSelection,Tim1OutputFreq_Value,Tim2OutputFreq_Value,TraceFreq_Value,USART16CLockSelection,USART16Freq_Value,USART234578CLockSelection,USART234578Freq_Value,USBCLockSelection,USBFreq_Value,VCO1OutputFreq_Value,VCO2OutputFreq_Value,VCO3OutputFreq_Value,VCOInput1Freq_Value,VCOInput2Freq_Value,VCOInput3Freq_Value,WatchDogFreq_Value +RCC.I2C4Freq_Value=140000000 +RCC.IPParameters=ADCCLockSelection,ADCFreq_Value,AHB12Freq_Value,AHB4Freq_Value,APB1Freq_Value,APB2Freq_Value,APB3Freq_Value,APB4Freq_Value,AXIClockFreq_Value,CDCPREFreq_Value,CDPPRE,CDPPRE1,CDPPRE2,CECCLockSelection,CECFreq_Value,CKPERFreq_Value,CKPERSourceSelection,CSI_VALUE,CortexFreq_Value,Cortex_Div,Cortex_DivARG,CpuClockFreq_Value,DAC1Freq_Value,DAC2Freq_Value,DFSDM2ACLkFreq_Value,DFSDM2Freq_Value,DFSDMACLkFreq_Value,DFSDMCLockSelection,DFSDMFreq_Value,DIVM1,DIVM2,DIVM3,DIVN1,DIVN2,DIVN3,DIVP1Freq_Value,DIVP2,DIVP2Freq_Value,DIVP3,DIVP3Freq_Value,DIVQ1,DIVQ1Freq_Value,DIVQ2,DIVQ2Freq_Value,DIVQ3,DIVQ3Freq_Value,DIVR1,DIVR1Freq_Value,DIVR2Freq_Value,DIVR3,DIVR3Freq_Value,EXTERNAL_CLOCK_VALUE,FDCANFreq_Value,FMCCLockSelection,FMCFreq_Value,FamilyName,HCLK3ClockFreq_Value,HCLKFreq_Value,HPRE,HSE_VALUE,HSI48_VALUE,HSIDiv,HSI_VALUE,I2C123CLockSelection,I2C123Freq_Value,I2C4CLockSelection,I2C4Freq_Value,LPTIM1CLockSelection,LPTIM1Freq_Value,LPTIM2CLockSelection,LPTIM2Freq_Value,LPTIM345CLockSelection,LPTIM345Freq_Value,LPUART1CLockSelection,LPUART1Freq_Value,LSI_VALUE,LTDCFreq_Value,MCO1PinFreq_Value,MCO2PinFreq_Value,PLL2FRACN,PLL3FRACN,PLLFRACN,PLLSourceVirtual,QSPICLockSelection,QSPIFreq_Value,RCC_MCO1Source,RCC_MCO2Source,RCC_MCODiv1,RCC_MCODiv2,RCC_RTC_Clock_Source_FROM_HSE,RNGCLockSelection,RNGFreq_Value,RTCFreq_Value,SAI1CLockSelection,SAI1Freq_Value,SAI2AFreq_Value,SAI2BCLockSelection,SAI2BFreq_Value,SDMMC1CLockSelection,SDMMCFreq_Value,SPDIFCLockSelection,SPDIFRXFreq_Value,SPI123CLockSelection,SPI123Freq_Value,SPI45Freq_Value,SPI6CLockSelection,SPI6Freq_Value,SRDPPRE,SWPCLockSelection,SWPMI1Freq_Value,SYSCLKFreq_VALUE,SYSCLKSource,Spi45ClockSelection,Tim1OutputFreq_Value,Tim2OutputFreq_Value,TraceFreq_Value,USART16CLockSelection,USART16Freq_Value,USART234578CLockSelection,USART234578Freq_Value,USBCLockSelection,USBFreq_Value,VCO1OutputFreq_Value,VCO2OutputFreq_Value,VCO3OutputFreq_Value,VCOInput1Freq_Value,VCOInput2Freq_Value,VCOInput3Freq_Value,WatchDogFreq_Value RCC.LPTIM1CLockSelection=RCC_LPTIM1CLKSOURCE_D2PCLK1 -RCC.LPTIM1Freq_Value=80000000 +RCC.LPTIM1Freq_Value=140000000 RCC.LPTIM2CLockSelection=RCC_LPTIM2CLKSOURCE_D3PCLK1 -RCC.LPTIM2Freq_Value=80000000 +RCC.LPTIM2Freq_Value=140000000 RCC.LPTIM345CLockSelection=RCC_LPTIM3CLKSOURCE_D3PCLK1 -RCC.LPTIM345Freq_Value=80000000 +RCC.LPTIM345Freq_Value=140000000 RCC.LPUART1CLockSelection=RCC_LPUART1CLKSOURCE_D3PCLK1 -RCC.LPUART1Freq_Value=80000000 +RCC.LPUART1Freq_Value=140000000 RCC.LSI_VALUE=32000 RCC.LTDCFreq_Value=64000000 RCC.MCO1PinFreq_Value=64000000 -RCC.MCO2PinFreq_Value=160000000 +RCC.MCO2PinFreq_Value=280000000 RCC.PLL2FRACN=0 RCC.PLL3FRACN=0 RCC.PLLFRACN=0 RCC.PLLSourceVirtual=RCC_PLLSOURCE_HSE RCC.QSPICLockSelection=RCC_OSPICLKSOURCE_D1HCLK -RCC.QSPIFreq_Value=160000000 +RCC.QSPIFreq_Value=280000000 RCC.RCC_MCO1Source=RCC_MCO1SOURCE_HSI RCC.RCC_MCO2Source=RCC_MCO2SOURCE_SYSCLK RCC.RCC_MCODiv1=RCC_MCODIV_1 @@ -508,39 +502,39 @@ RCC.RNGCLockSelection=RCC_RNGCLKSOURCE_HSI48 RCC.RNGFreq_Value=48000000 RCC.RTCFreq_Value=32000 RCC.SAI1CLockSelection=RCC_SAI1CLKSOURCE_PLL -RCC.SAI1Freq_Value=80000000 -RCC.SAI2AFreq_Value=80000000 +RCC.SAI1Freq_Value=140000000 +RCC.SAI2AFreq_Value=140000000 RCC.SAI2BCLockSelection=RCC_SAI2BCLKSOURCE_PLL -RCC.SAI2BFreq_Value=80000000 +RCC.SAI2BFreq_Value=140000000 RCC.SDMMC1CLockSelection=RCC_SDMMCCLKSOURCE_PLL2 -RCC.SDMMCFreq_Value=160000000 +RCC.SDMMCFreq_Value=280000000 RCC.SPDIFCLockSelection=RCC_SPDIFRXCLKSOURCE_PLL -RCC.SPDIFRXFreq_Value=80000000 +RCC.SPDIFRXFreq_Value=140000000 RCC.SPI123CLockSelection=RCC_SPI123CLKSOURCE_PLL -RCC.SPI123Freq_Value=80000000 -RCC.SPI45Freq_Value=80000000 +RCC.SPI123Freq_Value=140000000 +RCC.SPI45Freq_Value=140000000 RCC.SPI6CLockSelection=RCC_SPI6CLKSOURCE_D3PCLK1 -RCC.SPI6Freq_Value=80000000 +RCC.SPI6Freq_Value=140000000 RCC.SRDPPRE=RCC_APB4_DIV2 RCC.SWPCLockSelection=RCC_SWPMI1CLKSOURCE_D2PCLK1 -RCC.SWPMI1Freq_Value=80000000 -RCC.SYSCLKFreq_VALUE=160000000 +RCC.SWPMI1Freq_Value=140000000 +RCC.SYSCLKFreq_VALUE=280000000 RCC.SYSCLKSource=RCC_SYSCLKSOURCE_PLLCLK RCC.Spi45ClockSelection=RCC_SPI45CLKSOURCE_D2PCLK1 -RCC.Tim1OutputFreq_Value=160000000 -RCC.Tim2OutputFreq_Value=160000000 -RCC.TraceFreq_Value=160000000 +RCC.Tim1OutputFreq_Value=280000000 +RCC.Tim2OutputFreq_Value=280000000 +RCC.TraceFreq_Value=140000000 RCC.USART16CLockSelection=RCC_USART16910CLKSOURCE_D2PCLK2 -RCC.USART16Freq_Value=80000000 +RCC.USART16Freq_Value=140000000 RCC.USART234578CLockSelection=RCC_USART234578CLKSOURCE_D2PCLK1 -RCC.USART234578Freq_Value=80000000 +RCC.USART234578Freq_Value=140000000 RCC.USBCLockSelection=RCC_USBCLKSOURCE_HSI48 RCC.USBFreq_Value=48000000 -RCC.VCO1OutputFreq_Value=320000000 -RCC.VCO2OutputFreq_Value=320000000 +RCC.VCO1OutputFreq_Value=560000000 +RCC.VCO2OutputFreq_Value=560000000 RCC.VCO3OutputFreq_Value=192000000 -RCC.VCOInput1Freq_Value=16000000 -RCC.VCOInput2Freq_Value=16000000 +RCC.VCOInput1Freq_Value=8000000 +RCC.VCOInput2Freq_Value=8000000 RCC.VCOInput3Freq_Value=16000000 RCC.WatchDogFreq_Value=32000 SH.FMC_A0.0=FMC_A0,13b-sda1 diff --git a/Software/Makefile b/Software/Makefile index 619e4c9..3abeb31 100644 --- a/Software/Makefile +++ b/Software/Makefile @@ -1,5 +1,5 @@ ########################################################################################################################## -# File automatically-generated by tool: [projectgenerator] version: [4.5.0-RC5] date: [Mon Mar 31 16:30:20 CEST 2025] +# File automatically-generated by tool: [projectgenerator] version: [4.5.0-RC5] date: [Tue Apr 01 19:21:10 CEST 2025] ########################################################################################################################## # ------------------------------------------------ @@ -35,53 +35,47 @@ BUILD_DIR = build # source ###################################### # C sources -C_SOURCES = \ -Core/Src/main.c \ -Core/Src/stm32h7xx_it.c \ -Core/Src/stm32h7xx_hal_msp.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c \ -Core/Src/system_stm32h7xx.c \ -Core/Src/sysmem.c \ -Core/Src/syscalls.c +C_SOURCES = \ +Core/Src/main.c \ +Core/Src/stm32h7xx_it.c \ +Core/Src/stm32h7xx_hal_msp.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_crc_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_fdcan.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd_ex.c \ +Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c \ +Core/Src/system_stm32h7xx.c \ +Core/Src/sysmem.c \ +Core/Src/syscalls.c # ASM sources -ASM_SOURCES = \ +ASM_SOURCES = \ startup_stm32h7a3xx.s # ASM sources @@ -128,9 +122,9 @@ MCU = $(CPU) -mthumb $(FPU) $(FLOAT-ABI) AS_DEFS = # C defines -C_DEFS = \ --DUSE_PWR_LDO_SUPPLY \ --DUSE_HAL_DRIVER \ +C_DEFS = \ +-DUSE_PWR_LDO_SUPPLY \ +-DUSE_HAL_DRIVER \ -DSTM32H7A3xx @@ -138,11 +132,11 @@ C_DEFS = \ AS_INCLUDES = # C includes -C_INCLUDES = \ --ICore/Inc \ --IDrivers/STM32H7xx_HAL_Driver/Inc \ --IDrivers/STM32H7xx_HAL_Driver/Inc/Legacy \ --IDrivers/CMSIS/Device/ST/STM32H7xx/Include \ +C_INCLUDES = \ +-ICore/Inc \ +-IDrivers/STM32H7xx_HAL_Driver/Inc \ +-IDrivers/STM32H7xx_HAL_Driver/Inc/Legacy \ +-IDrivers/CMSIS/Device/ST/STM32H7xx/Include \ -IDrivers/CMSIS/Include @@ -219,4 +213,4 @@ clean: ####################################### -include $(wildcard $(BUILD_DIR)/*.d) -# *** EOF *** \ No newline at end of file +# *** EOF *** diff --git a/Software/STM32Make.make b/Software/STM32Make.make index c4a42f1..d2c5085 100644 --- a/Software/STM32Make.make +++ b/Software/STM32Make.make @@ -98,8 +98,6 @@ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_ltdc_ex.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mmc_ex.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nand.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_nor.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pcd.c \ @@ -108,15 +106,11 @@ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sd_ex.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sdram.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_sram.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_uart_ex.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_delayblock.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_fmc.c \ -Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_sdmmc.c \ Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_usb.c diff --git a/Software/build/FT23_Charger.map b/Software/build/FT23_Charger.map index b40a29b..d998bd2 100644 --- a/Software/build/FT23_Charger.map +++ b/Software/build/FT23_Charger.map @@ -914,6 +914,8 @@ Discarded input sections 0x00000000 0x42 build/debug/stm32h7xx_hal_ltdc.o .text.HAL_LTDC_SetAlpha 0x00000000 0x42 build/debug/stm32h7xx_hal_ltdc.o + .text.HAL_LTDC_SetAddress + 0x00000000 0x42 build/debug/stm32h7xx_hal_ltdc.o .text.HAL_LTDC_SetPitch 0x00000000 0xb4 build/debug/stm32h7xx_hal_ltdc.o .text.HAL_LTDC_Reload @@ -1017,30 +1019,6 @@ Discarded input sections .debug_frame 0x00000000 0x26c build/debug/stm32h7xx_hal_mdma.o .ARM.attributes 0x00000000 0x32 build/debug/stm32h7xx_hal_mdma.o - .text 0x00000000 0x0 build/debug/stm32h7xx_hal_mmc.o - .data 0x00000000 0x0 build/debug/stm32h7xx_hal_mmc.o - .bss 0x00000000 0x0 build/debug/stm32h7xx_hal_mmc.o - .debug_info 0x00000000 0x81 build/debug/stm32h7xx_hal_mmc.o - .debug_abbrev 0x00000000 0x26 build/debug/stm32h7xx_hal_mmc.o - .debug_aranges - 0x00000000 0x18 build/debug/stm32h7xx_hal_mmc.o - .debug_line 0x00000000 0x55 build/debug/stm32h7xx_hal_mmc.o - .debug_str 0x00000000 0x1aa build/debug/stm32h7xx_hal_mmc.o - .comment 0x00000000 0x24 build/debug/stm32h7xx_hal_mmc.o - .ARM.attributes - 0x00000000 0x32 build/debug/stm32h7xx_hal_mmc.o - .text 0x00000000 0x0 build/debug/stm32h7xx_hal_mmc_ex.o - .data 0x00000000 0x0 build/debug/stm32h7xx_hal_mmc_ex.o - .bss 0x00000000 0x0 build/debug/stm32h7xx_hal_mmc_ex.o - .debug_info 0x00000000 0x81 build/debug/stm32h7xx_hal_mmc_ex.o - .debug_abbrev 0x00000000 0x26 build/debug/stm32h7xx_hal_mmc_ex.o - .debug_aranges - 0x00000000 0x18 build/debug/stm32h7xx_hal_mmc_ex.o - .debug_line 0x00000000 0x58 build/debug/stm32h7xx_hal_mmc_ex.o - .debug_str 0x00000000 0x1ad build/debug/stm32h7xx_hal_mmc_ex.o - .comment 0x00000000 0x24 build/debug/stm32h7xx_hal_mmc_ex.o - .ARM.attributes - 0x00000000 0x32 build/debug/stm32h7xx_hal_mmc_ex.o .text 0x00000000 0x0 build/debug/stm32h7xx_hal_msp.o .data 0x00000000 0x0 build/debug/stm32h7xx_hal_msp.o .bss 0x00000000 0x0 build/debug/stm32h7xx_hal_msp.o @@ -1054,8 +1032,6 @@ Discarded input sections 0x00000000 0x3c build/debug/stm32h7xx_hal_msp.o .text.HAL_LTDC_MspDeInit 0x00000000 0x7c build/debug/stm32h7xx_hal_msp.o - .text.HAL_SD_MspDeInit - 0x00000000 0x4c build/debug/stm32h7xx_hal_msp.o .text.HAL_UART_MspDeInit 0x00000000 0x58 build/debug/stm32h7xx_hal_msp.o .text.HAL_PCD_MspDeInit @@ -1350,6 +1326,10 @@ Discarded input sections 0x00000000 0x1e0 build/debug/stm32h7xx_hal_rcc_ex.o .text.HAL_RCCEx_GetD1PCLK1Freq 0x00000000 0x24 build/debug/stm32h7xx_hal_rcc_ex.o + .text.HAL_RCCEx_GetPLL1ClockFreq + 0x00000000 0x200 build/debug/stm32h7xx_hal_rcc_ex.o + .text.HAL_RCCEx_GetPeriphCLKFreq + 0x00000000 0x620 build/debug/stm32h7xx_hal_rcc_ex.o .text.HAL_RCCEx_GetD1SysClockFreq 0x00000000 0x44 build/debug/stm32h7xx_hal_rcc_ex.o .text.HAL_RCCEx_EnableLSECSS @@ -1384,94 +1364,6 @@ Discarded input sections 0x00000000 0x2 build/debug/stm32h7xx_hal_rcc_ex.o .text.HAL_RCCEx_LSECSS_IRQHandler 0x00000000 0x20 build/debug/stm32h7xx_hal_rcc_ex.o - .text 0x00000000 0x0 build/debug/stm32h7xx_hal_sd.o - .data 0x00000000 0x0 build/debug/stm32h7xx_hal_sd.o - .bss 0x00000000 0x0 build/debug/stm32h7xx_hal_sd.o - .text.SD_PowerOFF - 0x00000000 0xa build/debug/stm32h7xx_hal_sd.o - .text.SD_Read_IT - 0x00000000 0x3c build/debug/stm32h7xx_hal_sd.o - .text.SD_Write_IT - 0x00000000 0x4c build/debug/stm32h7xx_hal_sd.o - .text.SD_SwitchSpeed - 0x00000000 0x114 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_MspInit - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_MspDeInit - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_DeInit - 0x00000000 0x24 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_ReadBlocks - 0x00000000 0x20c build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_WriteBlocks - 0x00000000 0x21c build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_ReadBlocks_IT - 0x00000000 0xd4 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_WriteBlocks_IT - 0x00000000 0xd0 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_ReadBlocks_DMA - 0x00000000 0xe0 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_WriteBlocks_DMA - 0x00000000 0xe0 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_Erase - 0x00000000 0xf8 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_GetState - 0x00000000 0x6 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_GetError - 0x00000000 0x4 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_TxCpltCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_RxCpltCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_ErrorCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_AbortCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_GetCardCID - 0x00000000 0x52 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_GetCardInfo - 0x00000000 0x24 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_ConfigSpeedBusOperation - 0x00000000 0x104 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_Abort - 0x00000000 0xf4 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_Abort_IT - 0x00000000 0x4c build/debug/stm32h7xx_hal_sd.o - .text.HAL_SDEx_Read_DMADoubleBuf0CpltCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SDEx_Read_DMADoubleBuf1CpltCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SDEx_Write_DMADoubleBuf0CpltCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SDEx_Write_DMADoubleBuf1CpltCallback - 0x00000000 0x2 build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_IRQHandler - 0x00000000 0x22c build/debug/stm32h7xx_hal_sd.o - .text 0x00000000 0x0 build/debug/stm32h7xx_hal_sd_ex.o - .data 0x00000000 0x0 build/debug/stm32h7xx_hal_sd_ex.o - .bss 0x00000000 0x0 build/debug/stm32h7xx_hal_sd_ex.o - .text.HAL_SDEx_ConfigDMAMultiBuffer - 0x00000000 0x26 build/debug/stm32h7xx_hal_sd_ex.o - .text.HAL_SDEx_ReadBlocksDMAMultiBuffer - 0x00000000 0xd4 build/debug/stm32h7xx_hal_sd_ex.o - .text.HAL_SDEx_WriteBlocksDMAMultiBuffer - 0x00000000 0xc0 build/debug/stm32h7xx_hal_sd_ex.o - .text.HAL_SDEx_ChangeDMABuffer - 0x00000000 0x10 build/debug/stm32h7xx_hal_sd_ex.o - .debug_info 0x00000000 0x7d8 build/debug/stm32h7xx_hal_sd_ex.o - .debug_abbrev 0x00000000 0x22d build/debug/stm32h7xx_hal_sd_ex.o - .debug_loclists - 0x00000000 0x355 build/debug/stm32h7xx_hal_sd_ex.o - .debug_aranges - 0x00000000 0x38 build/debug/stm32h7xx_hal_sd_ex.o - .debug_rnglists - 0x00000000 0x27 build/debug/stm32h7xx_hal_sd_ex.o - .debug_line 0x00000000 0x486 build/debug/stm32h7xx_hal_sd_ex.o - .debug_str 0x00000000 0x69f build/debug/stm32h7xx_hal_sd_ex.o - .comment 0x00000000 0x24 build/debug/stm32h7xx_hal_sd_ex.o - .debug_frame 0x00000000 0x84 build/debug/stm32h7xx_hal_sd_ex.o - .ARM.attributes - 0x00000000 0x32 build/debug/stm32h7xx_hal_sd_ex.o .text 0x00000000 0x0 build/debug/stm32h7xx_hal_sdram.o .data 0x00000000 0x0 build/debug/stm32h7xx_hal_sdram.o .bss 0x00000000 0x0 build/debug/stm32h7xx_hal_sdram.o @@ -1511,10 +1403,6 @@ Discarded input sections 0x00000000 0x32 build/debug/stm32h7xx_hal_sdram.o .text.HAL_SDRAM_WriteProtection_Disable 0x00000000 0x2e build/debug/stm32h7xx_hal_sdram.o - .text.HAL_SDRAM_SendCommand - 0x00000000 0x42 build/debug/stm32h7xx_hal_sdram.o - .text.HAL_SDRAM_ProgramRefreshRate - 0x00000000 0x30 build/debug/stm32h7xx_hal_sdram.o .text.HAL_SDRAM_SetAutoRefreshNumber 0x00000000 0x30 build/debug/stm32h7xx_hal_sdram.o .text.HAL_SDRAM_GetModeStatus @@ -1698,29 +1586,6 @@ Discarded input sections .text 0x00000000 0x0 build/debug/stm32h7xx_it.o .data 0x00000000 0x0 build/debug/stm32h7xx_it.o .bss 0x00000000 0x0 build/debug/stm32h7xx_it.o - .text 0x00000000 0x0 build/debug/stm32h7xx_ll_delayblock.o - .data 0x00000000 0x0 build/debug/stm32h7xx_ll_delayblock.o - .bss 0x00000000 0x0 build/debug/stm32h7xx_ll_delayblock.o - .text.DelayBlock_Enable - 0x00000000 0x8e build/debug/stm32h7xx_ll_delayblock.o - .text.DelayBlock_Disable - 0x00000000 0x8 build/debug/stm32h7xx_ll_delayblock.o - .text.DelayBlock_Configure - 0x00000000 0x1c build/debug/stm32h7xx_ll_delayblock.o - .debug_info 0x00000000 0x259 build/debug/stm32h7xx_ll_delayblock.o - .debug_abbrev 0x00000000 0x13c build/debug/stm32h7xx_ll_delayblock.o - .debug_loclists - 0x00000000 0x161 build/debug/stm32h7xx_ll_delayblock.o - .debug_aranges - 0x00000000 0x30 build/debug/stm32h7xx_ll_delayblock.o - .debug_rnglists - 0x00000000 0x20 build/debug/stm32h7xx_ll_delayblock.o - .debug_line 0x00000000 0x2c4 build/debug/stm32h7xx_ll_delayblock.o - .debug_str 0x00000000 0x2a1 build/debug/stm32h7xx_ll_delayblock.o - .comment 0x00000000 0x24 build/debug/stm32h7xx_ll_delayblock.o - .debug_frame 0x00000000 0x64 build/debug/stm32h7xx_ll_delayblock.o - .ARM.attributes - 0x00000000 0x32 build/debug/stm32h7xx_ll_delayblock.o .text 0x00000000 0x0 build/debug/stm32h7xx_ll_fmc.o .data 0x00000000 0x0 build/debug/stm32h7xx_ll_fmc.o .bss 0x00000000 0x0 build/debug/stm32h7xx_ll_fmc.o @@ -1756,73 +1621,10 @@ Discarded input sections 0x00000000 0x10 build/debug/stm32h7xx_ll_fmc.o .text.FMC_SDRAM_WriteProtection_Disable 0x00000000 0x10 build/debug/stm32h7xx_ll_fmc.o - .text.FMC_SDRAM_SendCommand - 0x00000000 0x2a build/debug/stm32h7xx_ll_fmc.o - .text.FMC_SDRAM_ProgramRefreshRate - 0x00000000 0x10 build/debug/stm32h7xx_ll_fmc.o .text.FMC_SDRAM_SetAutoRefreshNumber 0x00000000 0x12 build/debug/stm32h7xx_ll_fmc.o .text.FMC_SDRAM_GetModeStatus 0x00000000 0x14 build/debug/stm32h7xx_ll_fmc.o - .text 0x00000000 0x0 build/debug/stm32h7xx_ll_sdmmc.o - .data 0x00000000 0x0 build/debug/stm32h7xx_ll_sdmmc.o - .bss 0x00000000 0x0 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_WriteFIFO - 0x00000000 0xa build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_PowerState_Cycle - 0x00000000 0xc build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_PowerState_OFF - 0x00000000 0xc build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_GetDataCounter - 0x00000000 0x4 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_GetFIFOCount - 0x00000000 0x6 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_SetSDMMCReadWaitMode - 0x00000000 0xe build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdBlockCount - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdReadSingleBlock - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdReadMultiBlock - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdWriteSingleBlock - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdWriteMultiBlock - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdSDEraseStartAdd - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdSDEraseEndAdd - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdEraseStartAdd - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdEraseEndAdd - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdErase - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdStopTransfer - 0x00000000 0x58 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdSetRelAddMmc - 0x00000000 0x34 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdSleepMmc - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdSwitch - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdVoltageSwitch - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdSendEXTCSD - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdOpCondition - 0x00000000 0x2c build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_GetCmdResp4 - 0x00000000 0x60 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_CmdSendOperationcondition - 0x00000000 0x30 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_GetCmdResp5 - 0x00000000 0xbc build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_SDIO_CmdReadWriteDirect - 0x00000000 0x32 build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_SDIO_CmdReadWriteExtended - 0x00000000 0x30 build/debug/stm32h7xx_ll_sdmmc.o .text 0x00000000 0x0 build/debug/stm32h7xx_ll_usb.o .data 0x00000000 0x0 build/debug/stm32h7xx_ll_usb.o .bss 0x00000000 0x0 build/debug/stm32h7xx_ll_usb.o @@ -2497,8 +2299,6 @@ LOAD build/debug/stm32h7xx_hal_i2c_ex.o LOAD build/debug/stm32h7xx_hal_ltdc.o LOAD build/debug/stm32h7xx_hal_ltdc_ex.o LOAD build/debug/stm32h7xx_hal_mdma.o -LOAD build/debug/stm32h7xx_hal_mmc.o -LOAD build/debug/stm32h7xx_hal_mmc_ex.o LOAD build/debug/stm32h7xx_hal_msp.o LOAD build/debug/stm32h7xx_hal_nand.o LOAD build/debug/stm32h7xx_hal_nor.o @@ -2508,16 +2308,12 @@ LOAD build/debug/stm32h7xx_hal_pwr.o LOAD build/debug/stm32h7xx_hal_pwr_ex.o LOAD build/debug/stm32h7xx_hal_rcc.o LOAD build/debug/stm32h7xx_hal_rcc_ex.o -LOAD build/debug/stm32h7xx_hal_sd.o -LOAD build/debug/stm32h7xx_hal_sd_ex.o LOAD build/debug/stm32h7xx_hal_sdram.o LOAD build/debug/stm32h7xx_hal_sram.o LOAD build/debug/stm32h7xx_hal_uart.o LOAD build/debug/stm32h7xx_hal_uart_ex.o LOAD build/debug/stm32h7xx_it.o -LOAD build/debug/stm32h7xx_ll_delayblock.o LOAD build/debug/stm32h7xx_ll_fmc.o -LOAD build/debug/stm32h7xx_ll_sdmmc.o LOAD build/debug/stm32h7xx_ll_usb.o LOAD build/debug/syscalls.o LOAD build/debug/sysmem.o @@ -2547,7 +2343,7 @@ LOAD /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o 0x08000000 g_pfnVectors 0x080002ac . = ALIGN (0x4) -.text 0x080002ac 0x70d4 +.text 0x080002ac 0x57f0 0x080002ac . = ALIGN (0x4) *(.text) .text 0x080002ac 0x88 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o @@ -2567,714 +2363,593 @@ LOAD /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o .text.MX_FDCAN1_Init 0x08000800 0x60 build/debug/main.o .text.MX_FMC_Init - 0x08000860 0x70 build/debug/main.o + 0x08000860 0xd8 build/debug/main.o .text.MX_I2C4_Init - 0x080008d0 0x54 build/debug/main.o - .text.MX_SDMMC2_SD_Init - 0x08000924 0x28 build/debug/main.o + 0x08000938 0x54 build/debug/main.o .text.MX_USART10_UART_Init - 0x0800094c 0x60 build/debug/main.o + 0x0800098c 0x60 build/debug/main.o .text.MX_USB_OTG_HS_PCD_Init - 0x080009ac 0x38 build/debug/main.o + 0x080009ec 0x38 build/debug/main.o .text.MX_UART5_Init - 0x080009e4 0x60 build/debug/main.o + 0x08000a24 0x60 build/debug/main.o .text.MX_LTDC_Init - 0x08000a44 0xbc build/debug/main.o + 0x08000a84 0xbc build/debug/main.o .text.MX_CRC_Init - 0x08000b00 0x2c build/debug/main.o + 0x08000b40 0x2c build/debug/main.o .text.SystemClock_Config - 0x08000b2c 0xc0 build/debug/main.o - 0x08000b2c SystemClock_Config - .text.PeriphCommonClock_Config - 0x08000bec 0x48 build/debug/main.o - 0x08000bec PeriphCommonClock_Config - .text.main 0x08000c34 0x60 build/debug/main.o - 0x08000c34 main + 0x08000b6c 0xbc build/debug/main.o + 0x08000b6c SystemClock_Config + .text.main 0x08000c28 0x5c build/debug/main.o + 0x08000c28 main .text.HAL_InitTick - 0x08000c94 0x50 build/debug/stm32h7xx_hal.o - 0x08000c94 HAL_InitTick + 0x08000c84 0x50 build/debug/stm32h7xx_hal.o + 0x08000c84 HAL_InitTick .text.HAL_Init - 0x08000ce4 0x5c build/debug/stm32h7xx_hal.o - 0x08000ce4 HAL_Init + 0x08000cd4 0x5c build/debug/stm32h7xx_hal.o + 0x08000cd4 HAL_Init .text.HAL_IncTick - 0x08000d40 0x18 build/debug/stm32h7xx_hal.o - 0x08000d40 HAL_IncTick + 0x08000d30 0x18 build/debug/stm32h7xx_hal.o + 0x08000d30 HAL_IncTick .text.HAL_GetTick - 0x08000d58 0xc build/debug/stm32h7xx_hal.o - 0x08000d58 HAL_GetTick + 0x08000d48 0xc build/debug/stm32h7xx_hal.o + 0x08000d48 HAL_GetTick .text.HAL_Delay - 0x08000d64 0x28 build/debug/stm32h7xx_hal.o - 0x08000d64 HAL_Delay + 0x08000d54 0x28 build/debug/stm32h7xx_hal.o + 0x08000d54 HAL_Delay .text.__NVIC_EnableIRQ - 0x08000d8c 0x1c build/debug/stm32h7xx_hal_cortex.o + 0x08000d7c 0x1c build/debug/stm32h7xx_hal_cortex.o .text.__NVIC_SetPriority - 0x08000da8 0x24 build/debug/stm32h7xx_hal_cortex.o + 0x08000d98 0x24 build/debug/stm32h7xx_hal_cortex.o .text.NVIC_EncodePriority - 0x08000dcc 0x3e build/debug/stm32h7xx_hal_cortex.o - *fill* 0x08000e0a 0x2 + 0x08000dbc 0x3e build/debug/stm32h7xx_hal_cortex.o + *fill* 0x08000dfa 0x2 .text.HAL_NVIC_SetPriorityGrouping - 0x08000e0c 0x24 build/debug/stm32h7xx_hal_cortex.o - 0x08000e0c HAL_NVIC_SetPriorityGrouping + 0x08000dfc 0x24 build/debug/stm32h7xx_hal_cortex.o + 0x08000dfc HAL_NVIC_SetPriorityGrouping .text.HAL_NVIC_SetPriority - 0x08000e30 0x20 build/debug/stm32h7xx_hal_cortex.o - 0x08000e30 HAL_NVIC_SetPriority + 0x08000e20 0x20 build/debug/stm32h7xx_hal_cortex.o + 0x08000e20 HAL_NVIC_SetPriority .text.HAL_NVIC_EnableIRQ - 0x08000e50 0x8 build/debug/stm32h7xx_hal_cortex.o - 0x08000e50 HAL_NVIC_EnableIRQ + 0x08000e40 0x8 build/debug/stm32h7xx_hal_cortex.o + 0x08000e40 HAL_NVIC_EnableIRQ .text.HAL_SYSTICK_Config - 0x08000e58 0x28 build/debug/stm32h7xx_hal_cortex.o - 0x08000e58 HAL_SYSTICK_Config + 0x08000e48 0x28 build/debug/stm32h7xx_hal_cortex.o + 0x08000e48 HAL_SYSTICK_Config .text.HAL_CRC_Init - 0x08000e80 0x80 build/debug/stm32h7xx_hal_crc.o - 0x08000e80 HAL_CRC_Init + 0x08000e70 0x80 build/debug/stm32h7xx_hal_crc.o + 0x08000e70 HAL_CRC_Init .text.HAL_CRCEx_Polynomial_Set - 0x08000f00 0xc4 build/debug/stm32h7xx_hal_crc_ex.o - 0x08000f00 HAL_CRCEx_Polynomial_Set + 0x08000ef0 0xc4 build/debug/stm32h7xx_hal_crc_ex.o + 0x08000ef0 HAL_CRCEx_Polynomial_Set .text.FDCAN_CalcultateRamBlockAddresses - 0x08000fc4 0x1d4 build/debug/stm32h7xx_hal_fdcan.o + 0x08000fb4 0x1d4 build/debug/stm32h7xx_hal_fdcan.o .text.HAL_FDCAN_Init - 0x08001198 0x294 build/debug/stm32h7xx_hal_fdcan.o - 0x08001198 HAL_FDCAN_Init + 0x08001188 0x294 build/debug/stm32h7xx_hal_fdcan.o + 0x08001188 HAL_FDCAN_Init .text.HAL_FDCAN_ClockCalibrationCallback - 0x0800142c 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x0800142c HAL_FDCAN_ClockCalibrationCallback + 0x0800141c 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x0800141c HAL_FDCAN_ClockCalibrationCallback .text.HAL_FDCAN_TxEventFifoCallback - 0x0800142e 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x0800142e HAL_FDCAN_TxEventFifoCallback + 0x0800141e 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x0800141e HAL_FDCAN_TxEventFifoCallback .text.HAL_FDCAN_RxFifo0Callback - 0x08001430 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001430 HAL_FDCAN_RxFifo0Callback + 0x08001420 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001420 HAL_FDCAN_RxFifo0Callback .text.HAL_FDCAN_RxFifo1Callback - 0x08001432 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001432 HAL_FDCAN_RxFifo1Callback + 0x08001422 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001422 HAL_FDCAN_RxFifo1Callback .text.HAL_FDCAN_TxFifoEmptyCallback - 0x08001434 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001434 HAL_FDCAN_TxFifoEmptyCallback + 0x08001424 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001424 HAL_FDCAN_TxFifoEmptyCallback .text.HAL_FDCAN_TxBufferCompleteCallback - 0x08001436 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001436 HAL_FDCAN_TxBufferCompleteCallback + 0x08001426 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001426 HAL_FDCAN_TxBufferCompleteCallback .text.HAL_FDCAN_TxBufferAbortCallback - 0x08001438 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001438 HAL_FDCAN_TxBufferAbortCallback + 0x08001428 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001428 HAL_FDCAN_TxBufferAbortCallback .text.HAL_FDCAN_RxBufferNewMessageCallback - 0x0800143a 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x0800143a HAL_FDCAN_RxBufferNewMessageCallback + 0x0800142a 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x0800142a HAL_FDCAN_RxBufferNewMessageCallback .text.HAL_FDCAN_TimestampWraparoundCallback - 0x0800143c 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x0800143c HAL_FDCAN_TimestampWraparoundCallback + 0x0800142c 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x0800142c HAL_FDCAN_TimestampWraparoundCallback .text.HAL_FDCAN_TimeoutOccurredCallback - 0x0800143e 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x0800143e HAL_FDCAN_TimeoutOccurredCallback + 0x0800142e 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x0800142e HAL_FDCAN_TimeoutOccurredCallback .text.HAL_FDCAN_HighPriorityMessageCallback - 0x08001440 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001440 HAL_FDCAN_HighPriorityMessageCallback + 0x08001430 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001430 HAL_FDCAN_HighPriorityMessageCallback .text.HAL_FDCAN_ErrorCallback - 0x08001442 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001442 HAL_FDCAN_ErrorCallback + 0x08001432 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001432 HAL_FDCAN_ErrorCallback .text.HAL_FDCAN_ErrorStatusCallback - 0x08001444 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001444 HAL_FDCAN_ErrorStatusCallback + 0x08001434 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001434 HAL_FDCAN_ErrorStatusCallback .text.HAL_FDCAN_TT_ScheduleSyncCallback - 0x08001446 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001446 HAL_FDCAN_TT_ScheduleSyncCallback + 0x08001436 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001436 HAL_FDCAN_TT_ScheduleSyncCallback .text.HAL_FDCAN_TT_TimeMarkCallback - 0x08001448 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x08001448 HAL_FDCAN_TT_TimeMarkCallback + 0x08001438 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x08001438 HAL_FDCAN_TT_TimeMarkCallback .text.HAL_FDCAN_TT_StopWatchCallback - 0x0800144a 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x0800144a HAL_FDCAN_TT_StopWatchCallback + 0x0800143a 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x0800143a HAL_FDCAN_TT_StopWatchCallback .text.HAL_FDCAN_TT_GlobalTimeCallback - 0x0800144c 0x2 build/debug/stm32h7xx_hal_fdcan.o - 0x0800144c HAL_FDCAN_TT_GlobalTimeCallback - *fill* 0x0800144e 0x2 + 0x0800143c 0x2 build/debug/stm32h7xx_hal_fdcan.o + 0x0800143c HAL_FDCAN_TT_GlobalTimeCallback + *fill* 0x0800143e 0x2 .text.HAL_FDCAN_IRQHandler - 0x08001450 0x320 build/debug/stm32h7xx_hal_fdcan.o - 0x08001450 HAL_FDCAN_IRQHandler + 0x08001440 0x320 build/debug/stm32h7xx_hal_fdcan.o + 0x08001440 HAL_FDCAN_IRQHandler .text.HAL_GPIO_Init - 0x08001770 0x220 build/debug/stm32h7xx_hal_gpio.o - 0x08001770 HAL_GPIO_Init + 0x08001760 0x220 build/debug/stm32h7xx_hal_gpio.o + 0x08001760 HAL_GPIO_Init .text.HAL_GPIO_WritePin - 0x08001990 0xc build/debug/stm32h7xx_hal_gpio.o - 0x08001990 HAL_GPIO_WritePin + 0x08001980 0xc build/debug/stm32h7xx_hal_gpio.o + 0x08001980 HAL_GPIO_WritePin .text.HAL_I2C_Init - 0x0800199c 0xc8 build/debug/stm32h7xx_hal_i2c.o - 0x0800199c HAL_I2C_Init + 0x0800198c 0xc8 build/debug/stm32h7xx_hal_i2c.o + 0x0800198c HAL_I2C_Init .text.HAL_I2CEx_ConfigAnalogFilter - 0x08001a64 0x5a build/debug/stm32h7xx_hal_i2c_ex.o - 0x08001a64 HAL_I2CEx_ConfigAnalogFilter + 0x08001a54 0x5a build/debug/stm32h7xx_hal_i2c_ex.o + 0x08001a54 HAL_I2CEx_ConfigAnalogFilter .text.HAL_I2CEx_ConfigDigitalFilter - 0x08001abe 0x56 build/debug/stm32h7xx_hal_i2c_ex.o - 0x08001abe HAL_I2CEx_ConfigDigitalFilter + 0x08001aae 0x56 build/debug/stm32h7xx_hal_i2c_ex.o + 0x08001aae HAL_I2CEx_ConfigDigitalFilter .text.LTDC_SetConfig - 0x08001b14 0x1a8 build/debug/stm32h7xx_hal_ltdc.o + 0x08001b04 0x1a8 build/debug/stm32h7xx_hal_ltdc.o .text.HAL_LTDC_Init - 0x08001cbc 0xbc build/debug/stm32h7xx_hal_ltdc.o - 0x08001cbc HAL_LTDC_Init + 0x08001cac 0xbc build/debug/stm32h7xx_hal_ltdc.o + 0x08001cac HAL_LTDC_Init .text.HAL_LTDC_ErrorCallback - 0x08001d78 0x2 build/debug/stm32h7xx_hal_ltdc.o - 0x08001d78 HAL_LTDC_ErrorCallback + 0x08001d68 0x2 build/debug/stm32h7xx_hal_ltdc.o + 0x08001d68 HAL_LTDC_ErrorCallback .text.HAL_LTDC_LineEventCallback - 0x08001d7a 0x2 build/debug/stm32h7xx_hal_ltdc.o - 0x08001d7a HAL_LTDC_LineEventCallback + 0x08001d6a 0x2 build/debug/stm32h7xx_hal_ltdc.o + 0x08001d6a HAL_LTDC_LineEventCallback .text.HAL_LTDC_ReloadEventCallback - 0x08001d7c 0x2 build/debug/stm32h7xx_hal_ltdc.o - 0x08001d7c HAL_LTDC_ReloadEventCallback + 0x08001d6c 0x2 build/debug/stm32h7xx_hal_ltdc.o + 0x08001d6c HAL_LTDC_ReloadEventCallback .text.HAL_LTDC_IRQHandler - 0x08001d7e 0xda build/debug/stm32h7xx_hal_ltdc.o - 0x08001d7e HAL_LTDC_IRQHandler + 0x08001d6e 0xda build/debug/stm32h7xx_hal_ltdc.o + 0x08001d6e HAL_LTDC_IRQHandler .text.HAL_LTDC_ConfigLayer - 0x08001e58 0x68 build/debug/stm32h7xx_hal_ltdc.o - 0x08001e58 HAL_LTDC_ConfigLayer - .text.HAL_LTDC_SetAddress - 0x08001ec0 0x42 build/debug/stm32h7xx_hal_ltdc.o - 0x08001ec0 HAL_LTDC_SetAddress - *fill* 0x08001f02 0x2 + 0x08001e48 0x68 build/debug/stm32h7xx_hal_ltdc.o + 0x08001e48 HAL_LTDC_ConfigLayer .text.HAL_LTDC_ProgramLineEvent - 0x08001f04 0x48 build/debug/stm32h7xx_hal_ltdc.o - 0x08001f04 HAL_LTDC_ProgramLineEvent + 0x08001eb0 0x48 build/debug/stm32h7xx_hal_ltdc.o + 0x08001eb0 HAL_LTDC_ProgramLineEvent .text.HAL_FMC_MspInit - 0x08001f4c 0x104 build/debug/stm32h7xx_hal_msp.o + 0x08001ef8 0x144 build/debug/stm32h7xx_hal_msp.o .text.HAL_MspInit - 0x08002050 0x24 build/debug/stm32h7xx_hal_msp.o - 0x08002050 HAL_MspInit + 0x0800203c 0x24 build/debug/stm32h7xx_hal_msp.o + 0x0800203c HAL_MspInit .text.HAL_CRC_MspInit - 0x08002074 0x34 build/debug/stm32h7xx_hal_msp.o - 0x08002074 HAL_CRC_MspInit + 0x08002060 0x34 build/debug/stm32h7xx_hal_msp.o + 0x08002060 HAL_CRC_MspInit .text.HAL_FDCAN_MspInit - 0x080020a8 0xd4 build/debug/stm32h7xx_hal_msp.o - 0x080020a8 HAL_FDCAN_MspInit + 0x08002094 0xd4 build/debug/stm32h7xx_hal_msp.o + 0x08002094 HAL_FDCAN_MspInit .text.HAL_I2C_MspInit - 0x0800217c 0x98 build/debug/stm32h7xx_hal_msp.o - 0x0800217c HAL_I2C_MspInit + 0x08002168 0x98 build/debug/stm32h7xx_hal_msp.o + 0x08002168 HAL_I2C_MspInit .text.HAL_LTDC_MspInit - 0x08002214 0x22c build/debug/stm32h7xx_hal_msp.o - 0x08002214 HAL_LTDC_MspInit - .text.HAL_SD_MspInit - 0x08002440 0xe4 build/debug/stm32h7xx_hal_msp.o - 0x08002440 HAL_SD_MspInit + 0x08002200 0x240 build/debug/stm32h7xx_hal_msp.o + 0x08002200 HAL_LTDC_MspInit .text.HAL_UART_MspInit - 0x08002524 0x10c build/debug/stm32h7xx_hal_msp.o - 0x08002524 HAL_UART_MspInit + 0x08002440 0x10c build/debug/stm32h7xx_hal_msp.o + 0x08002440 HAL_UART_MspInit .text.HAL_PCD_MspInit - 0x08002630 0xb8 build/debug/stm32h7xx_hal_msp.o - 0x08002630 HAL_PCD_MspInit + 0x0800254c 0xb8 build/debug/stm32h7xx_hal_msp.o + 0x0800254c HAL_PCD_MspInit .text.HAL_SDRAM_MspInit - 0x080026e8 0x8 build/debug/stm32h7xx_hal_msp.o - 0x080026e8 HAL_SDRAM_MspInit + 0x08002604 0x8 build/debug/stm32h7xx_hal_msp.o + 0x08002604 HAL_SDRAM_MspInit .text.HAL_PCD_Init - 0x080026f0 0x102 build/debug/stm32h7xx_hal_pcd.o - 0x080026f0 HAL_PCD_Init - *fill* 0x080027f2 0x2 + 0x0800260c 0x102 build/debug/stm32h7xx_hal_pcd.o + 0x0800260c HAL_PCD_Init + *fill* 0x0800270e 0x2 .text.HAL_PCDEx_ActivateLPM - 0x080027f4 0x28 build/debug/stm32h7xx_hal_pcd_ex.o - 0x080027f4 HAL_PCDEx_ActivateLPM + 0x08002710 0x28 build/debug/stm32h7xx_hal_pcd_ex.o + 0x08002710 HAL_PCDEx_ActivateLPM .text.HAL_PWREx_ConfigSupply - 0x0800281c 0x54 build/debug/stm32h7xx_hal_pwr_ex.o - 0x0800281c HAL_PWREx_ConfigSupply + 0x08002738 0x54 build/debug/stm32h7xx_hal_pwr_ex.o + 0x08002738 HAL_PWREx_ConfigSupply .text.HAL_PWREx_EnableUSBVoltageDetector - 0x08002870 0x10 build/debug/stm32h7xx_hal_pwr_ex.o - 0x08002870 HAL_PWREx_EnableUSBVoltageDetector + 0x0800278c 0x10 build/debug/stm32h7xx_hal_pwr_ex.o + 0x0800278c HAL_PWREx_EnableUSBVoltageDetector .text.HAL_RCC_OscConfig - 0x08002880 0x660 build/debug/stm32h7xx_hal_rcc.o - 0x08002880 HAL_RCC_OscConfig + 0x0800279c 0x660 build/debug/stm32h7xx_hal_rcc.o + 0x0800279c HAL_RCC_OscConfig .text.HAL_RCC_GetSysClockFreq - 0x08002ee0 0x1f8 build/debug/stm32h7xx_hal_rcc.o - 0x08002ee0 HAL_RCC_GetSysClockFreq + 0x08002dfc 0x1f8 build/debug/stm32h7xx_hal_rcc.o + 0x08002dfc HAL_RCC_GetSysClockFreq .text.HAL_RCC_ClockConfig - 0x080030d8 0x294 build/debug/stm32h7xx_hal_rcc.o - 0x080030d8 HAL_RCC_ClockConfig + 0x08002ff4 0x294 build/debug/stm32h7xx_hal_rcc.o + 0x08002ff4 HAL_RCC_ClockConfig .text.HAL_RCC_GetHCLKFreq - 0x0800336c 0x44 build/debug/stm32h7xx_hal_rcc.o - 0x0800336c HAL_RCC_GetHCLKFreq + 0x08003288 0x44 build/debug/stm32h7xx_hal_rcc.o + 0x08003288 HAL_RCC_GetHCLKFreq .text.HAL_RCC_GetPCLK1Freq - 0x080033b0 0x24 build/debug/stm32h7xx_hal_rcc.o - 0x080033b0 HAL_RCC_GetPCLK1Freq + 0x080032cc 0x24 build/debug/stm32h7xx_hal_rcc.o + 0x080032cc HAL_RCC_GetPCLK1Freq .text.HAL_RCC_GetPCLK2Freq - 0x080033d4 0x24 build/debug/stm32h7xx_hal_rcc.o - 0x080033d4 HAL_RCC_GetPCLK2Freq + 0x080032f0 0x24 build/debug/stm32h7xx_hal_rcc.o + 0x080032f0 HAL_RCC_GetPCLK2Freq .text.RCCEx_PLL2_Config - 0x080033f8 0x108 build/debug/stm32h7xx_hal_rcc_ex.o + 0x08003314 0x108 build/debug/stm32h7xx_hal_rcc_ex.o .text.RCCEx_PLL3_Config - 0x08003500 0x108 build/debug/stm32h7xx_hal_rcc_ex.o + 0x0800341c 0x108 build/debug/stm32h7xx_hal_rcc_ex.o .text.HAL_RCCEx_PeriphCLKConfig - 0x08003608 0xb1c build/debug/stm32h7xx_hal_rcc_ex.o - 0x08003608 HAL_RCCEx_PeriphCLKConfig + 0x08003524 0xb1c build/debug/stm32h7xx_hal_rcc_ex.o + 0x08003524 HAL_RCCEx_PeriphCLKConfig .text.HAL_RCCEx_GetD3PCLK1Freq - 0x08004124 0x24 build/debug/stm32h7xx_hal_rcc_ex.o - 0x08004124 HAL_RCCEx_GetD3PCLK1Freq + 0x08004040 0x24 build/debug/stm32h7xx_hal_rcc_ex.o + 0x08004040 HAL_RCCEx_GetD3PCLK1Freq .text.HAL_RCCEx_GetPLL2ClockFreq - 0x08004148 0x200 build/debug/stm32h7xx_hal_rcc_ex.o - 0x08004148 HAL_RCCEx_GetPLL2ClockFreq + 0x08004064 0x200 build/debug/stm32h7xx_hal_rcc_ex.o + 0x08004064 HAL_RCCEx_GetPLL2ClockFreq .text.HAL_RCCEx_GetPLL3ClockFreq - 0x08004348 0x200 build/debug/stm32h7xx_hal_rcc_ex.o - 0x08004348 HAL_RCCEx_GetPLL3ClockFreq - .text.HAL_RCCEx_GetPLL1ClockFreq - 0x08004548 0x200 build/debug/stm32h7xx_hal_rcc_ex.o - 0x08004548 HAL_RCCEx_GetPLL1ClockFreq - .text.HAL_RCCEx_GetPeriphCLKFreq - 0x08004748 0x620 build/debug/stm32h7xx_hal_rcc_ex.o - 0x08004748 HAL_RCCEx_GetPeriphCLKFreq - .text.SD_PowerON - 0x08004d68 0xc4 build/debug/stm32h7xx_hal_sd.o - .text.SD_SendSDStatus - 0x08004e2c 0x108 build/debug/stm32h7xx_hal_sd.o - .text.SD_FindSCR - 0x08004f34 0x108 build/debug/stm32h7xx_hal_sd.o - .text.SD_WideBus_Enable - 0x0800503c 0x4e build/debug/stm32h7xx_hal_sd.o - .text.SD_WideBus_Disable - 0x0800508a 0x4e build/debug/stm32h7xx_hal_sd.o - .text.SD_SendStatus - 0x080050d8 0x2c build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_GetCardCSD - 0x08005104 0x1b8 build/debug/stm32h7xx_hal_sd.o - 0x08005104 HAL_SD_GetCardCSD - .text.SD_InitCard - 0x080052bc 0xfc build/debug/stm32h7xx_hal_sd.o - .text.HAL_SD_InitCard - 0x080053b8 0xd4 build/debug/stm32h7xx_hal_sd.o - 0x080053b8 HAL_SD_InitCard - .text.HAL_SD_GetCardStatus - 0x0800548c 0xcc build/debug/stm32h7xx_hal_sd.o - 0x0800548c HAL_SD_GetCardStatus - .text.HAL_SD_ConfigWideBusOperation - 0x08005558 0x158 build/debug/stm32h7xx_hal_sd.o - 0x08005558 HAL_SD_ConfigWideBusOperation - .text.HAL_SD_GetCardState - 0x080056b0 0x22 build/debug/stm32h7xx_hal_sd.o - 0x080056b0 HAL_SD_GetCardState - .text.HAL_SD_Init - 0x080056d2 0xba build/debug/stm32h7xx_hal_sd.o - 0x080056d2 HAL_SD_Init + 0x08004264 0x200 build/debug/stm32h7xx_hal_rcc_ex.o + 0x08004264 HAL_RCCEx_GetPLL3ClockFreq .text.HAL_SDRAM_Init - 0x0800578c 0x50 build/debug/stm32h7xx_hal_sdram.o - 0x0800578c HAL_SDRAM_Init + 0x08004464 0x50 build/debug/stm32h7xx_hal_sdram.o + 0x08004464 HAL_SDRAM_Init .text.HAL_SDRAM_RefreshErrorCallback - 0x080057dc 0x2 build/debug/stm32h7xx_hal_sdram.o - 0x080057dc HAL_SDRAM_RefreshErrorCallback + 0x080044b4 0x2 build/debug/stm32h7xx_hal_sdram.o + 0x080044b4 HAL_SDRAM_RefreshErrorCallback .text.HAL_SDRAM_IRQHandler - 0x080057de 0x20 build/debug/stm32h7xx_hal_sdram.o - 0x080057de HAL_SDRAM_IRQHandler - *fill* 0x080057fe 0x2 + 0x080044b6 0x20 build/debug/stm32h7xx_hal_sdram.o + 0x080044b6 HAL_SDRAM_IRQHandler + .text.HAL_SDRAM_SendCommand + 0x080044d6 0x42 build/debug/stm32h7xx_hal_sdram.o + 0x080044d6 HAL_SDRAM_SendCommand + .text.HAL_SDRAM_ProgramRefreshRate + 0x08004518 0x30 build/debug/stm32h7xx_hal_sdram.o + 0x08004518 HAL_SDRAM_ProgramRefreshRate .text.UART_EndRxTransfer - 0x08005800 0x58 build/debug/stm32h7xx_hal_uart.o + 0x08004548 0x58 build/debug/stm32h7xx_hal_uart.o .text.UART_SetConfig - 0x08005858 0x9f8 build/debug/stm32h7xx_hal_uart.o - 0x08005858 UART_SetConfig + 0x080045a0 0x9f8 build/debug/stm32h7xx_hal_uart.o + 0x080045a0 UART_SetConfig .text.UART_AdvFeatureConfig - 0x08006250 0xca build/debug/stm32h7xx_hal_uart.o - 0x08006250 UART_AdvFeatureConfig + 0x08004f98 0xca build/debug/stm32h7xx_hal_uart.o + 0x08004f98 UART_AdvFeatureConfig .text.UART_WaitOnFlagUntilTimeout - 0x0800631a 0xa6 build/debug/stm32h7xx_hal_uart.o - 0x0800631a UART_WaitOnFlagUntilTimeout + 0x08005062 0xa6 build/debug/stm32h7xx_hal_uart.o + 0x08005062 UART_WaitOnFlagUntilTimeout .text.UART_CheckIdleState - 0x080063c0 0xca build/debug/stm32h7xx_hal_uart.o - 0x080063c0 UART_CheckIdleState + 0x08005108 0xca build/debug/stm32h7xx_hal_uart.o + 0x08005108 UART_CheckIdleState .text.HAL_UART_Init - 0x0800648a 0x66 build/debug/stm32h7xx_hal_uart.o - 0x0800648a HAL_UART_Init + 0x080051d2 0x66 build/debug/stm32h7xx_hal_uart.o + 0x080051d2 HAL_UART_Init .text.UARTEx_SetNbDataToProcess - 0x080064f0 0x4c build/debug/stm32h7xx_hal_uart_ex.o + 0x08005238 0x4c build/debug/stm32h7xx_hal_uart_ex.o .text.HAL_UARTEx_DisableFifoMode - 0x0800653c 0x3e build/debug/stm32h7xx_hal_uart_ex.o - 0x0800653c HAL_UARTEx_DisableFifoMode + 0x08005284 0x3e build/debug/stm32h7xx_hal_uart_ex.o + 0x08005284 HAL_UARTEx_DisableFifoMode .text.HAL_UARTEx_SetTxFifoThreshold - 0x0800657a 0x4a build/debug/stm32h7xx_hal_uart_ex.o - 0x0800657a HAL_UARTEx_SetTxFifoThreshold + 0x080052c2 0x4a build/debug/stm32h7xx_hal_uart_ex.o + 0x080052c2 HAL_UARTEx_SetTxFifoThreshold .text.HAL_UARTEx_SetRxFifoThreshold - 0x080065c4 0x4a build/debug/stm32h7xx_hal_uart_ex.o - 0x080065c4 HAL_UARTEx_SetRxFifoThreshold + 0x0800530c 0x4a build/debug/stm32h7xx_hal_uart_ex.o + 0x0800530c HAL_UARTEx_SetRxFifoThreshold .text.NMI_Handler - 0x0800660e 0x2 build/debug/stm32h7xx_it.o - 0x0800660e NMI_Handler + 0x08005356 0x2 build/debug/stm32h7xx_it.o + 0x08005356 NMI_Handler .text.HardFault_Handler - 0x08006610 0x2 build/debug/stm32h7xx_it.o - 0x08006610 HardFault_Handler + 0x08005358 0x2 build/debug/stm32h7xx_it.o + 0x08005358 HardFault_Handler .text.MemManage_Handler - 0x08006612 0x2 build/debug/stm32h7xx_it.o - 0x08006612 MemManage_Handler + 0x0800535a 0x2 build/debug/stm32h7xx_it.o + 0x0800535a MemManage_Handler .text.BusFault_Handler - 0x08006614 0x2 build/debug/stm32h7xx_it.o - 0x08006614 BusFault_Handler + 0x0800535c 0x2 build/debug/stm32h7xx_it.o + 0x0800535c BusFault_Handler .text.UsageFault_Handler - 0x08006616 0x2 build/debug/stm32h7xx_it.o - 0x08006616 UsageFault_Handler + 0x0800535e 0x2 build/debug/stm32h7xx_it.o + 0x0800535e UsageFault_Handler .text.SVC_Handler - 0x08006618 0x2 build/debug/stm32h7xx_it.o - 0x08006618 SVC_Handler + 0x08005360 0x2 build/debug/stm32h7xx_it.o + 0x08005360 SVC_Handler .text.DebugMon_Handler - 0x0800661a 0x2 build/debug/stm32h7xx_it.o - 0x0800661a DebugMon_Handler + 0x08005362 0x2 build/debug/stm32h7xx_it.o + 0x08005362 DebugMon_Handler .text.PendSV_Handler - 0x0800661c 0x2 build/debug/stm32h7xx_it.o - 0x0800661c PendSV_Handler + 0x08005364 0x2 build/debug/stm32h7xx_it.o + 0x08005364 PendSV_Handler .text.SysTick_Handler - 0x0800661e 0x8 build/debug/stm32h7xx_it.o - 0x0800661e SysTick_Handler - *fill* 0x08006626 0x2 + 0x08005366 0x8 build/debug/stm32h7xx_it.o + 0x08005366 SysTick_Handler + *fill* 0x0800536e 0x2 .text.FDCAN1_IT0_IRQHandler - 0x08006628 0x10 build/debug/stm32h7xx_it.o - 0x08006628 FDCAN1_IT0_IRQHandler + 0x08005370 0x10 build/debug/stm32h7xx_it.o + 0x08005370 FDCAN1_IT0_IRQHandler .text.FDCAN1_IT1_IRQHandler - 0x08006638 0x10 build/debug/stm32h7xx_it.o - 0x08006638 FDCAN1_IT1_IRQHandler + 0x08005380 0x10 build/debug/stm32h7xx_it.o + 0x08005380 FDCAN1_IT1_IRQHandler .text.FMC_IRQHandler - 0x08006648 0x10 build/debug/stm32h7xx_it.o - 0x08006648 FMC_IRQHandler + 0x08005390 0x10 build/debug/stm32h7xx_it.o + 0x08005390 FMC_IRQHandler .text.FDCAN_CAL_IRQHandler - 0x08006658 0x10 build/debug/stm32h7xx_it.o - 0x08006658 FDCAN_CAL_IRQHandler + 0x080053a0 0x10 build/debug/stm32h7xx_it.o + 0x080053a0 FDCAN_CAL_IRQHandler .text.LTDC_IRQHandler - 0x08006668 0x18 build/debug/stm32h7xx_it.o - 0x08006668 LTDC_IRQHandler + 0x080053b0 0x18 build/debug/stm32h7xx_it.o + 0x080053b0 LTDC_IRQHandler .text.FMC_SDRAM_Init - 0x08006680 0x70 build/debug/stm32h7xx_ll_fmc.o - 0x08006680 FMC_SDRAM_Init + 0x080053c8 0x70 build/debug/stm32h7xx_ll_fmc.o + 0x080053c8 FMC_SDRAM_Init .text.FMC_SDRAM_Timing_Init - 0x080066f0 0xa8 build/debug/stm32h7xx_ll_fmc.o - 0x080066f0 FMC_SDRAM_Timing_Init - .text.SDMMC_GetCmdError - 0x08006798 0x3c build/debug/stm32h7xx_ll_sdmmc.o - .text.SDMMC_Init - 0x080067d4 0x30 build/debug/stm32h7xx_ll_sdmmc.o - 0x080067d4 SDMMC_Init - .text.SDMMC_ReadFIFO - 0x08006804 0x6 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006804 SDMMC_ReadFIFO - .text.SDMMC_PowerState_ON - 0x0800680a 0xc build/debug/stm32h7xx_ll_sdmmc.o - 0x0800680a SDMMC_PowerState_ON - .text.SDMMC_GetPowerState - 0x08006816 0x8 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006816 SDMMC_GetPowerState - *fill* 0x0800681e 0x2 - .text.SDMMC_SendCommand - 0x08006820 0x24 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006820 SDMMC_SendCommand - .text.SDMMC_GetCommandResponse - 0x08006844 0x6 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006844 SDMMC_GetCommandResponse - .text.SDMMC_GetResponse - 0x0800684a 0x6 build/debug/stm32h7xx_ll_sdmmc.o - 0x0800684a SDMMC_GetResponse - .text.SDMMC_ConfigData - 0x08006850 0x24 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006850 SDMMC_ConfigData - .text.SDMMC_CmdGoIdleState - 0x08006874 0x26 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006874 SDMMC_CmdGoIdleState - *fill* 0x0800689a 0x2 - .text.SDMMC_GetCmdResp1 - 0x0800689c 0x160 build/debug/stm32h7xx_ll_sdmmc.o - 0x0800689c SDMMC_GetCmdResp1 - .text.SDMMC_CmdBlockLength - 0x080069fc 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x080069fc SDMMC_CmdBlockLength - .text.SDMMC_CmdSelDesel - 0x08006a2e 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006a2e SDMMC_CmdSelDesel - .text.SDMMC_CmdAppCommand - 0x08006a60 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006a60 SDMMC_CmdAppCommand - .text.SDMMC_CmdBusWidth - 0x08006a92 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006a92 SDMMC_CmdBusWidth - .text.SDMMC_CmdSendSCR - 0x08006ac4 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006ac4 SDMMC_CmdSendSCR - .text.SDMMC_CmdSendStatus - 0x08006af6 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006af6 SDMMC_CmdSendStatus - .text.SDMMC_CmdStatusRegister - 0x08006b28 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006b28 SDMMC_CmdStatusRegister - *fill* 0x08006b5a 0x2 - .text.SDMMC_GetCmdResp2 - 0x08006b5c 0x60 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006b5c SDMMC_GetCmdResp2 - .text.SDMMC_CmdSendCID - 0x08006bbc 0x2c build/debug/stm32h7xx_ll_sdmmc.o - 0x08006bbc SDMMC_CmdSendCID - .text.SDMMC_CmdSendCSD - 0x08006be8 0x2c build/debug/stm32h7xx_ll_sdmmc.o - 0x08006be8 SDMMC_CmdSendCSD - .text.SDMMC_GetCmdResp3 - 0x08006c14 0x50 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006c14 SDMMC_GetCmdResp3 - .text.SDMMC_CmdAppOperCommand - 0x08006c64 0x2c build/debug/stm32h7xx_ll_sdmmc.o - 0x08006c64 SDMMC_CmdAppOperCommand - .text.SDMMC_GetCmdResp6 - 0x08006c90 0xa4 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006c90 SDMMC_GetCmdResp6 - .text.SDMMC_CmdSetRelAdd - 0x08006d34 0x32 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006d34 SDMMC_CmdSetRelAdd - *fill* 0x08006d66 0x2 - .text.SDMMC_GetCmdResp7 - 0x08006d68 0x64 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006d68 SDMMC_GetCmdResp7 - .text.SDMMC_CmdOperCond - 0x08006dcc 0x30 build/debug/stm32h7xx_ll_sdmmc.o - 0x08006dcc SDMMC_CmdOperCond + 0x08005438 0xa8 build/debug/stm32h7xx_ll_fmc.o + 0x08005438 FMC_SDRAM_Timing_Init + .text.FMC_SDRAM_SendCommand + 0x080054e0 0x2a build/debug/stm32h7xx_ll_fmc.o + 0x080054e0 FMC_SDRAM_SendCommand + .text.FMC_SDRAM_ProgramRefreshRate + 0x0800550a 0x10 build/debug/stm32h7xx_ll_fmc.o + 0x0800550a FMC_SDRAM_ProgramRefreshRate .text.USB_CoreReset - 0x08006dfc 0x4a build/debug/stm32h7xx_ll_usb.o - *fill* 0x08006e46 0x2 + 0x0800551a 0x4a build/debug/stm32h7xx_ll_usb.o .text.USB_CoreInit - 0x08006e48 0xa4 build/debug/stm32h7xx_ll_usb.o - 0x08006e48 USB_CoreInit + 0x08005564 0xa4 build/debug/stm32h7xx_ll_usb.o + 0x08005564 USB_CoreInit .text.USB_DisableGlobalInt - 0x08006eec 0xc build/debug/stm32h7xx_ll_usb.o - 0x08006eec USB_DisableGlobalInt + 0x08005608 0xc build/debug/stm32h7xx_ll_usb.o + 0x08005608 USB_DisableGlobalInt .text.USB_FlushTxFifo - 0x08006ef8 0x4a build/debug/stm32h7xx_ll_usb.o - 0x08006ef8 USB_FlushTxFifo + 0x08005614 0x4a build/debug/stm32h7xx_ll_usb.o + 0x08005614 USB_FlushTxFifo .text.USB_FlushRxFifo - 0x08006f42 0x46 build/debug/stm32h7xx_ll_usb.o - 0x08006f42 USB_FlushRxFifo + 0x0800565e 0x46 build/debug/stm32h7xx_ll_usb.o + 0x0800565e USB_FlushRxFifo .text.USB_SetDevSpeed - 0x08006f88 0xe build/debug/stm32h7xx_ll_usb.o - 0x08006f88 USB_SetDevSpeed - *fill* 0x08006f96 0x2 + 0x080056a4 0xe build/debug/stm32h7xx_ll_usb.o + 0x080056a4 USB_SetDevSpeed + *fill* 0x080056b2 0x2 .text.USB_DevInit - 0x08006f98 0x190 build/debug/stm32h7xx_ll_usb.o - 0x08006f98 USB_DevInit + 0x080056b4 0x190 build/debug/stm32h7xx_ll_usb.o + 0x080056b4 USB_DevInit .text.USB_DevDisconnect - 0x08007128 0x1c build/debug/stm32h7xx_ll_usb.o - 0x08007128 USB_DevDisconnect + 0x08005844 0x1c build/debug/stm32h7xx_ll_usb.o + 0x08005844 USB_DevDisconnect .text.USB_GetMode - 0x08007144 0x8 build/debug/stm32h7xx_ll_usb.o - 0x08007144 USB_GetMode + 0x08005860 0x8 build/debug/stm32h7xx_ll_usb.o + 0x08005860 USB_GetMode .text.USB_SetCurrentMode - 0x0800714c 0x62 build/debug/stm32h7xx_ll_usb.o - 0x0800714c USB_SetCurrentMode - *fill* 0x080071ae 0x2 + 0x08005868 0x62 build/debug/stm32h7xx_ll_usb.o + 0x08005868 USB_SetCurrentMode + *fill* 0x080058ca 0x2 .text.SystemInit - 0x080071b0 0xd0 build/debug/system_stm32h7xx.o - 0x080071b0 SystemInit + 0x080058cc 0xd0 build/debug/system_stm32h7xx.o + 0x080058cc SystemInit .text.ExitRun0Mode - 0x08007280 0x1c build/debug/system_stm32h7xx.o - 0x08007280 ExitRun0Mode + 0x0800599c 0x1c build/debug/system_stm32h7xx.o + 0x0800599c ExitRun0Mode .text.Reset_Handler - 0x0800729c 0x54 build/debug/startup_stm32h7a3xx.o - 0x0800729c Reset_Handler + 0x080059b8 0x54 build/debug/startup_stm32h7a3xx.o + 0x080059b8 Reset_Handler .text.Default_Handler - 0x080072f0 0x2 build/debug/startup_stm32h7a3xx.o - 0x080072f0 RTC_Alarm_IRQHandler - 0x080072f0 EXTI2_IRQHandler - 0x080072f0 TIM8_CC_IRQHandler - 0x080072f0 UART8_IRQHandler - 0x080072f0 BDMA2_Channel1_IRQHandler - 0x080072f0 SPI4_IRQHandler - 0x080072f0 BDMA2_Channel0_IRQHandler - 0x080072f0 TIM1_CC_IRQHandler - 0x080072f0 DMA2_Stream5_IRQHandler - 0x080072f0 JPEG_IRQHandler - 0x080072f0 DMA1_Stream5_IRQHandler - 0x080072f0 EXTI3_IRQHandler - 0x080072f0 LPTIM4_IRQHandler - 0x080072f0 TIM8_TRG_COM_TIM14_IRQHandler - 0x080072f0 LPTIM2_IRQHandler - 0x080072f0 DFSDM1_FLT1_IRQHandler - 0x080072f0 DMAMUX2_OVR_IRQHandler - 0x080072f0 GFXMMU_IRQHandler - 0x080072f0 TIM8_UP_TIM13_IRQHandler - 0x080072f0 I2C3_ER_IRQHandler - 0x080072f0 DFSDM1_FLT2_IRQHandler - 0x080072f0 USART10_IRQHandler - 0x080072f0 MDMA_IRQHandler - 0x080072f0 LPTIM3_IRQHandler - 0x080072f0 BDMA2_Channel3_IRQHandler - 0x080072f0 HSEM1_IRQHandler - 0x080072f0 EXTI0_IRQHandler - 0x080072f0 I2C2_EV_IRQHandler - 0x080072f0 DAC2_IRQHandler - 0x080072f0 DMA1_Stream2_IRQHandler - 0x080072f0 FPU_IRQHandler - 0x080072f0 OTG_HS_WKUP_IRQHandler - 0x080072f0 LTDC_ER_IRQHandler - 0x080072f0 DMA2_Stream2_IRQHandler - 0x080072f0 SPI1_IRQHandler - 0x080072f0 OCTOSPI1_IRQHandler - 0x080072f0 TIM6_DAC_IRQHandler - 0x080072f0 BDMA2_Channel6_IRQHandler - 0x080072f0 DMA2_Stream3_IRQHandler - 0x080072f0 OCTOSPI2_IRQHandler - 0x080072f0 SAI2_IRQHandler - 0x080072f0 BDMA1_IRQHandler - 0x080072f0 DFSDM1_FLT3_IRQHandler - 0x080072f0 USART6_IRQHandler - 0x080072f0 TIM17_IRQHandler - 0x080072f0 USART3_IRQHandler - 0x080072f0 LPTIM5_IRQHandler - 0x080072f0 UART5_IRQHandler - 0x080072f0 DMA2_Stream0_IRQHandler - 0x080072f0 TIM4_IRQHandler - 0x080072f0 I2C1_EV_IRQHandler - 0x080072f0 DMA1_Stream6_IRQHandler - 0x080072f0 DMAMUX1_OVR_IRQHandler - 0x080072f0 DMA1_Stream1_IRQHandler - 0x080072f0 TIM16_IRQHandler - 0x080072f0 UART4_IRQHandler - 0x080072f0 TIM3_IRQHandler - 0x080072f0 RCC_IRQHandler - 0x080072f0 UART9_IRQHandler - 0x080072f0 TIM8_BRK_TIM12_IRQHandler - 0x080072f0 TIM1_TRG_COM_IRQHandler - 0x080072f0 Default_Handler - 0x080072f0 ECC_IRQHandler - 0x080072f0 BDMA2_Channel2_IRQHandler - 0x080072f0 CEC_IRQHandler - 0x080072f0 EXTI15_10_IRQHandler - 0x080072f0 DFSDM1_FLT4_IRQHandler - 0x080072f0 ADC_IRQHandler - 0x080072f0 DMA1_Stream7_IRQHandler - 0x080072f0 SPI5_IRQHandler - 0x080072f0 TIM7_IRQHandler - 0x080072f0 SDMMC1_IRQHandler - 0x080072f0 TIM5_IRQHandler - 0x080072f0 DMA2_Stream7_IRQHandler - 0x080072f0 TIM15_IRQHandler - 0x080072f0 I2C3_EV_IRQHandler - 0x080072f0 DFSDM2_IRQHandler - 0x080072f0 EXTI9_5_IRQHandler - 0x080072f0 RTC_WKUP_IRQHandler - 0x080072f0 SPDIF_RX_IRQHandler - 0x080072f0 PVD_PVM_IRQHandler - 0x080072f0 SPI2_IRQHandler - 0x080072f0 OTG_HS_EP1_IN_IRQHandler - 0x080072f0 DFSDM1_FLT5_IRQHandler - 0x080072f0 DMA1_Stream0_IRQHandler - 0x080072f0 CRS_IRQHandler - 0x080072f0 EXTI4_IRQHandler - 0x080072f0 DFSDM1_FLT6_IRQHandler - 0x080072f0 RNG_IRQHandler - 0x080072f0 FDCAN2_IT1_IRQHandler - 0x080072f0 COMP_IRQHandler - 0x080072f0 TIM1_UP_IRQHandler - 0x080072f0 OTG_HS_EP1_OUT_IRQHandler - 0x080072f0 WWDG_IRQHandler - 0x080072f0 SPI6_IRQHandler - 0x080072f0 MDIOS_IRQHandler - 0x080072f0 I2C4_EV_IRQHandler - 0x080072f0 FDCAN2_IT0_IRQHandler - 0x080072f0 LPUART1_IRQHandler - 0x080072f0 TIM2_IRQHandler - 0x080072f0 BDMA2_Channel5_IRQHandler - 0x080072f0 OTG_HS_IRQHandler - 0x080072f0 DMA2D_IRQHandler - 0x080072f0 TIM1_BRK_IRQHandler - 0x080072f0 EXTI1_IRQHandler - 0x080072f0 SDMMC2_IRQHandler - 0x080072f0 DTS_IRQHandler - 0x080072f0 UART7_IRQHandler - 0x080072f0 MDIOS_WKUP_IRQHandler - 0x080072f0 USART2_IRQHandler - 0x080072f0 DFSDM1_FLT0_IRQHandler - 0x080072f0 I2C2_ER_IRQHandler - 0x080072f0 DMA2_Stream1_IRQHandler - 0x080072f0 DFSDM1_FLT7_IRQHandler - 0x080072f0 FLASH_IRQHandler - 0x080072f0 DMA2_Stream4_IRQHandler - 0x080072f0 USART1_IRQHandler - 0x080072f0 SPI3_IRQHandler - 0x080072f0 WAKEUP_PIN_IRQHandler - 0x080072f0 DMA1_Stream4_IRQHandler - 0x080072f0 I2C1_ER_IRQHandler - 0x080072f0 BDMA2_Channel7_IRQHandler - 0x080072f0 SWPMI1_IRQHandler - 0x080072f0 LPTIM1_IRQHandler - 0x080072f0 DCMI_PSSI_IRQHandler - 0x080072f0 I2C4_ER_IRQHandler - 0x080072f0 DMA2_Stream6_IRQHandler - 0x080072f0 SAI1_IRQHandler - 0x080072f0 DMA1_Stream3_IRQHandler - 0x080072f0 RTC_TAMP_STAMP_CSS_LSE_IRQHandler - 0x080072f0 BDMA2_Channel4_IRQHandler - .text.memset 0x080072f2 0x10 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) - 0x080072f2 memset - *fill* 0x08007302 0x2 + 0x08005a0c 0x2 build/debug/startup_stm32h7a3xx.o + 0x08005a0c RTC_Alarm_IRQHandler + 0x08005a0c EXTI2_IRQHandler + 0x08005a0c TIM8_CC_IRQHandler + 0x08005a0c UART8_IRQHandler + 0x08005a0c BDMA2_Channel1_IRQHandler + 0x08005a0c SPI4_IRQHandler + 0x08005a0c BDMA2_Channel0_IRQHandler + 0x08005a0c TIM1_CC_IRQHandler + 0x08005a0c DMA2_Stream5_IRQHandler + 0x08005a0c JPEG_IRQHandler + 0x08005a0c DMA1_Stream5_IRQHandler + 0x08005a0c EXTI3_IRQHandler + 0x08005a0c LPTIM4_IRQHandler + 0x08005a0c TIM8_TRG_COM_TIM14_IRQHandler + 0x08005a0c LPTIM2_IRQHandler + 0x08005a0c DFSDM1_FLT1_IRQHandler + 0x08005a0c DMAMUX2_OVR_IRQHandler + 0x08005a0c GFXMMU_IRQHandler + 0x08005a0c TIM8_UP_TIM13_IRQHandler + 0x08005a0c I2C3_ER_IRQHandler + 0x08005a0c DFSDM1_FLT2_IRQHandler + 0x08005a0c USART10_IRQHandler + 0x08005a0c MDMA_IRQHandler + 0x08005a0c LPTIM3_IRQHandler + 0x08005a0c BDMA2_Channel3_IRQHandler + 0x08005a0c HSEM1_IRQHandler + 0x08005a0c EXTI0_IRQHandler + 0x08005a0c I2C2_EV_IRQHandler + 0x08005a0c DAC2_IRQHandler + 0x08005a0c DMA1_Stream2_IRQHandler + 0x08005a0c FPU_IRQHandler + 0x08005a0c OTG_HS_WKUP_IRQHandler + 0x08005a0c LTDC_ER_IRQHandler + 0x08005a0c DMA2_Stream2_IRQHandler + 0x08005a0c SPI1_IRQHandler + 0x08005a0c OCTOSPI1_IRQHandler + 0x08005a0c TIM6_DAC_IRQHandler + 0x08005a0c BDMA2_Channel6_IRQHandler + 0x08005a0c DMA2_Stream3_IRQHandler + 0x08005a0c OCTOSPI2_IRQHandler + 0x08005a0c SAI2_IRQHandler + 0x08005a0c BDMA1_IRQHandler + 0x08005a0c DFSDM1_FLT3_IRQHandler + 0x08005a0c USART6_IRQHandler + 0x08005a0c TIM17_IRQHandler + 0x08005a0c USART3_IRQHandler + 0x08005a0c LPTIM5_IRQHandler + 0x08005a0c UART5_IRQHandler + 0x08005a0c DMA2_Stream0_IRQHandler + 0x08005a0c TIM4_IRQHandler + 0x08005a0c I2C1_EV_IRQHandler + 0x08005a0c DMA1_Stream6_IRQHandler + 0x08005a0c DMAMUX1_OVR_IRQHandler + 0x08005a0c DMA1_Stream1_IRQHandler + 0x08005a0c TIM16_IRQHandler + 0x08005a0c UART4_IRQHandler + 0x08005a0c TIM3_IRQHandler + 0x08005a0c RCC_IRQHandler + 0x08005a0c UART9_IRQHandler + 0x08005a0c TIM8_BRK_TIM12_IRQHandler + 0x08005a0c TIM1_TRG_COM_IRQHandler + 0x08005a0c Default_Handler + 0x08005a0c ECC_IRQHandler + 0x08005a0c BDMA2_Channel2_IRQHandler + 0x08005a0c CEC_IRQHandler + 0x08005a0c EXTI15_10_IRQHandler + 0x08005a0c DFSDM1_FLT4_IRQHandler + 0x08005a0c ADC_IRQHandler + 0x08005a0c DMA1_Stream7_IRQHandler + 0x08005a0c SPI5_IRQHandler + 0x08005a0c TIM7_IRQHandler + 0x08005a0c SDMMC1_IRQHandler + 0x08005a0c TIM5_IRQHandler + 0x08005a0c DMA2_Stream7_IRQHandler + 0x08005a0c TIM15_IRQHandler + 0x08005a0c I2C3_EV_IRQHandler + 0x08005a0c DFSDM2_IRQHandler + 0x08005a0c EXTI9_5_IRQHandler + 0x08005a0c RTC_WKUP_IRQHandler + 0x08005a0c SPDIF_RX_IRQHandler + 0x08005a0c PVD_PVM_IRQHandler + 0x08005a0c SPI2_IRQHandler + 0x08005a0c OTG_HS_EP1_IN_IRQHandler + 0x08005a0c DFSDM1_FLT5_IRQHandler + 0x08005a0c DMA1_Stream0_IRQHandler + 0x08005a0c CRS_IRQHandler + 0x08005a0c EXTI4_IRQHandler + 0x08005a0c DFSDM1_FLT6_IRQHandler + 0x08005a0c RNG_IRQHandler + 0x08005a0c FDCAN2_IT1_IRQHandler + 0x08005a0c COMP_IRQHandler + 0x08005a0c TIM1_UP_IRQHandler + 0x08005a0c OTG_HS_EP1_OUT_IRQHandler + 0x08005a0c WWDG_IRQHandler + 0x08005a0c SPI6_IRQHandler + 0x08005a0c MDIOS_IRQHandler + 0x08005a0c I2C4_EV_IRQHandler + 0x08005a0c FDCAN2_IT0_IRQHandler + 0x08005a0c LPUART1_IRQHandler + 0x08005a0c TIM2_IRQHandler + 0x08005a0c BDMA2_Channel5_IRQHandler + 0x08005a0c OTG_HS_IRQHandler + 0x08005a0c DMA2D_IRQHandler + 0x08005a0c TIM1_BRK_IRQHandler + 0x08005a0c EXTI1_IRQHandler + 0x08005a0c SDMMC2_IRQHandler + 0x08005a0c DTS_IRQHandler + 0x08005a0c UART7_IRQHandler + 0x08005a0c MDIOS_WKUP_IRQHandler + 0x08005a0c USART2_IRQHandler + 0x08005a0c DFSDM1_FLT0_IRQHandler + 0x08005a0c I2C2_ER_IRQHandler + 0x08005a0c DMA2_Stream1_IRQHandler + 0x08005a0c DFSDM1_FLT7_IRQHandler + 0x08005a0c FLASH_IRQHandler + 0x08005a0c DMA2_Stream4_IRQHandler + 0x08005a0c USART1_IRQHandler + 0x08005a0c SPI3_IRQHandler + 0x08005a0c WAKEUP_PIN_IRQHandler + 0x08005a0c DMA1_Stream4_IRQHandler + 0x08005a0c I2C1_ER_IRQHandler + 0x08005a0c BDMA2_Channel7_IRQHandler + 0x08005a0c SWPMI1_IRQHandler + 0x08005a0c LPTIM1_IRQHandler + 0x08005a0c DCMI_PSSI_IRQHandler + 0x08005a0c I2C4_ER_IRQHandler + 0x08005a0c DMA2_Stream6_IRQHandler + 0x08005a0c SAI1_IRQHandler + 0x08005a0c DMA1_Stream3_IRQHandler + 0x08005a0c RTC_TAMP_STAMP_CSS_LSE_IRQHandler + 0x08005a0c BDMA2_Channel4_IRQHandler + .text.memset 0x08005a0e 0x10 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + 0x08005a0e memset + *fill* 0x08005a1e 0x2 .text.__libc_init_array - 0x08007304 0x48 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - 0x08007304 __libc_init_array - .text.memcpy 0x0800734c 0x1c /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - 0x0800734c memcpy + 0x08005a20 0x48 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + 0x08005a20 __libc_init_array + .text.memcpy 0x08005a68 0x1c /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + 0x08005a68 memcpy *(.glue_7) - .glue_7 0x08007368 0x0 linker stubs + .glue_7 0x08005a84 0x0 linker stubs *(.glue_7t) - .glue_7t 0x08007368 0x0 linker stubs + .glue_7t 0x08005a84 0x0 linker stubs *(.eh_frame) - .eh_frame 0x08007368 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o + .eh_frame 0x08005a84 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o *(.init) - .init 0x08007368 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crti.o - 0x08007368 _init - .init 0x0800736c 0x8 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o + .init 0x08005a84 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crti.o + 0x08005a84 _init + .init 0x08005a88 0x8 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o *(.fini) - .fini 0x08007374 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crti.o - 0x08007374 _fini - .fini 0x08007378 0x8 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o - 0x08007380 . = ALIGN (0x4) - 0x08007380 _etext = . + .fini 0x08005a90 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crti.o + 0x08005a90 _fini + .fini 0x08005a94 0x8 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o + 0x08005a9c . = ALIGN (0x4) + 0x08005a9c _etext = . -.vfp11_veneer 0x08007380 0x0 - .vfp11_veneer 0x08007380 0x0 linker stubs +.vfp11_veneer 0x08005a9c 0x0 + .vfp11_veneer 0x08005a9c 0x0 linker stubs -.v4_bx 0x08007380 0x0 - .v4_bx 0x08007380 0x0 linker stubs +.v4_bx 0x08005a9c 0x0 + .v4_bx 0x08005a9c 0x0 linker stubs -.iplt 0x08007380 0x0 - .iplt 0x08007380 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o +.iplt 0x08005a9c 0x0 + .iplt 0x08005a9c 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o -.rodata 0x08007380 0x84 - 0x08007380 . = ALIGN (0x4) +.rodata 0x08005a9c 0x8c + 0x08005a9c . = ALIGN (0x4) *(.rodata) - .rodata 0x08007380 0x4c build/debug/stm32h7xx_hal_fdcan.o + .rodata 0x08005a9c 0x4c build/debug/stm32h7xx_hal_fdcan.o *(.rodata*) + .rodata.main.str1.4 + 0x08005ae8 0x6 build/debug/main.o + *fill* 0x08005aee 0x2 .rodata.UARTPrescTable - 0x080073cc 0x18 build/debug/stm32h7xx_hal_uart.o - 0x080073cc UARTPrescTable + 0x08005af0 0x18 build/debug/stm32h7xx_hal_uart.o + 0x08005af0 UARTPrescTable .rodata.denominator.0 - 0x080073e4 0x8 build/debug/stm32h7xx_hal_uart_ex.o + 0x08005b08 0x8 build/debug/stm32h7xx_hal_uart_ex.o .rodata.numerator.1 - 0x080073ec 0x8 build/debug/stm32h7xx_hal_uart_ex.o + 0x08005b10 0x8 build/debug/stm32h7xx_hal_uart_ex.o .rodata.D1CorePrescTable - 0x080073f4 0x10 build/debug/system_stm32h7xx.o - 0x080073f4 D1CorePrescTable - 0x08007404 . = ALIGN (0x4) + 0x08005b18 0x10 build/debug/system_stm32h7xx.o + 0x08005b18 D1CorePrescTable + 0x08005b28 . = ALIGN (0x4) .ARM.extab *(.ARM.extab* .gnu.linkonce.armextab.*) -.ARM 0x08007404 0x8 - 0x08007404 __exidx_start = . +.ARM 0x08005b28 0x8 + 0x08005b28 __exidx_start = . *(.ARM.exidx*) - .ARM.exidx 0x08007404 0x8 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) - 0x0800740c __exidx_end = . + .ARM.exidx 0x08005b28 0x8 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + 0x08005b30 __exidx_end = . -.rel.dyn 0x0800740c 0x0 - .rel.iplt 0x0800740c 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o +.rel.dyn 0x08005b30 0x0 + .rel.iplt 0x08005b30 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o -.preinit_array 0x0800740c 0x0 - 0x0800740c PROVIDE (__preinit_array_start = .) +.preinit_array 0x08005b30 0x0 + 0x08005b30 PROVIDE (__preinit_array_start = .) *(.preinit_array*) - 0x0800740c PROVIDE (__preinit_array_end = .) + 0x08005b30 PROVIDE (__preinit_array_end = .) -.init_array 0x0800740c 0x4 - 0x0800740c PROVIDE (__init_array_start = .) +.init_array 0x08005b30 0x4 + 0x08005b30 PROVIDE (__init_array_start = .) *(SORT_BY_NAME(.init_array.*)) *(.init_array*) - .init_array 0x0800740c 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o - 0x08007410 PROVIDE (__init_array_end = .) + .init_array 0x08005b30 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o + 0x08005b34 PROVIDE (__init_array_end = .) -.fini_array 0x08007410 0x4 - 0x08007410 PROVIDE (__fini_array_start = .) +.fini_array 0x08005b34 0x4 + 0x08005b34 PROVIDE (__fini_array_start = .) *(SORT_BY_NAME(.fini_array.*)) *(.fini_array*) - .fini_array 0x08007410 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o - 0x08007414 PROVIDE (__fini_array_end = .) - 0x08007414 _sidata = LOADADDR (.data) + .fini_array 0x08005b34 0x4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o + 0x08005b38 PROVIDE (__fini_array_end = .) + 0x08005b38 _sidata = LOADADDR (.data) -.data 0x20000000 0x10 load address 0x08007414 +.data 0x20000000 0x10 load address 0x08005b38 0x20000000 . = ALIGN (0x4) 0x20000000 _sdata = . *(.data) @@ -3296,52 +2971,47 @@ LOAD /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o 0x20000010 _edata = . .tm_clone_table - 0x20000010 0x0 load address 0x08007424 + 0x20000010 0x0 load address 0x08005b48 .tm_clone_table 0x20000010 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o .tm_clone_table 0x20000010 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtend.o -.igot.plt 0x20000010 0x0 load address 0x08007424 +.igot.plt 0x20000010 0x0 load address 0x08005b48 .igot.plt 0x20000010 0x0 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o 0x20000010 . = ALIGN (0x4) -.bss 0x24000000 0x404a0 +.bss 0x24000000 0x824 0x24000000 _sbss = . 0x24000000 __bss_start__ = _sbss *(.bss) .bss 0x24000000 0x1c /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o *(.bss*) - .bss.framebuffer - 0x2400001c 0x3fc00 build/debug/main.o - 0x2400001c framebuffer - .bss.hsdram1 0x2403fc1c 0x34 build/debug/main.o - 0x2403fc1c hsdram1 + .bss.hsdram1 0x2400001c 0x34 build/debug/main.o + 0x2400001c hsdram1 .bss.hpcd_USB_OTG_HS - 0x2403fc50 0x4e4 build/debug/main.o - 0x2403fc50 hpcd_USB_OTG_HS - .bss.huart10 0x24040134 0x94 build/debug/main.o - 0x24040134 huart10 - .bss.huart5 0x240401c8 0x94 build/debug/main.o - 0x240401c8 huart5 - .bss.hsd2 0x2404025c 0x7c build/debug/main.o - 0x2404025c hsd2 - .bss.hltdc 0x240402d8 0xa8 build/debug/main.o - 0x240402d8 hltdc - .bss.hi2c4 0x24040380 0x54 build/debug/main.o - 0x24040380 hi2c4 - .bss.hfdcan1 0x240403d4 0xa0 build/debug/main.o - 0x240403d4 hfdcan1 - .bss.hcrc 0x24040474 0x24 build/debug/main.o - 0x24040474 hcrc - .bss.uwTick 0x24040498 0x4 build/debug/stm32h7xx_hal.o - 0x24040498 uwTick + 0x24000050 0x4e4 build/debug/main.o + 0x24000050 hpcd_USB_OTG_HS + .bss.huart10 0x24000534 0x94 build/debug/main.o + 0x24000534 huart10 + .bss.huart5 0x240005c8 0x94 build/debug/main.o + 0x240005c8 huart5 + .bss.hltdc 0x2400065c 0xa8 build/debug/main.o + 0x2400065c hltdc + .bss.hi2c4 0x24000704 0x54 build/debug/main.o + 0x24000704 hi2c4 + .bss.hfdcan1 0x24000758 0xa0 build/debug/main.o + 0x24000758 hfdcan1 + .bss.hcrc 0x240007f8 0x24 build/debug/main.o + 0x240007f8 hcrc + .bss.uwTick 0x2400081c 0x4 build/debug/stm32h7xx_hal.o + 0x2400081c uwTick .bss.FMC_Initialized - 0x2404049c 0x4 build/debug/stm32h7xx_hal_msp.o + 0x24000820 0x4 build/debug/stm32h7xx_hal_msp.o *(COMMON) - 0x240404a0 . = ALIGN (0x4) - 0x240404a0 _ebss = . - 0x240404a0 __bss_end__ = _ebss + 0x24000824 . = ALIGN (0x4) + 0x24000824 _ebss = . + 0x24000824 __bss_end__ = _ebss ._user_heap_stack 0x20000010 0x600 @@ -3403,41 +3073,37 @@ LOAD /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a .ARM.attributes 0x00000340 0x32 build/debug/stm32h7xx_hal_rcc_ex.o .ARM.attributes - 0x00000372 0x32 build/debug/stm32h7xx_hal_sd.o + 0x00000372 0x32 build/debug/stm32h7xx_hal_sdram.o .ARM.attributes - 0x000003a4 0x32 build/debug/stm32h7xx_hal_sdram.o + 0x000003a4 0x32 build/debug/stm32h7xx_hal_uart.o .ARM.attributes - 0x000003d6 0x32 build/debug/stm32h7xx_hal_uart.o + 0x000003d6 0x32 build/debug/stm32h7xx_hal_uart_ex.o .ARM.attributes - 0x00000408 0x32 build/debug/stm32h7xx_hal_uart_ex.o + 0x00000408 0x32 build/debug/stm32h7xx_it.o .ARM.attributes - 0x0000043a 0x32 build/debug/stm32h7xx_it.o + 0x0000043a 0x32 build/debug/stm32h7xx_ll_fmc.o .ARM.attributes - 0x0000046c 0x32 build/debug/stm32h7xx_ll_fmc.o + 0x0000046c 0x32 build/debug/stm32h7xx_ll_usb.o .ARM.attributes - 0x0000049e 0x32 build/debug/stm32h7xx_ll_sdmmc.o + 0x0000049e 0x32 build/debug/system_stm32h7xx.o .ARM.attributes - 0x000004d0 0x32 build/debug/stm32h7xx_ll_usb.o + 0x000004d0 0x21 build/debug/startup_stm32h7a3xx.o .ARM.attributes - 0x00000502 0x32 build/debug/system_stm32h7xx.o + 0x000004f1 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) .ARM.attributes - 0x00000534 0x21 build/debug/startup_stm32h7a3xx.o + 0x00000523 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) .ARM.attributes - 0x00000555 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + 0x00000555 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) .ARM.attributes - 0x00000587 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + 0x00000587 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) .ARM.attributes - 0x000005b9 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + 0x000005a7 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) .ARM.attributes - 0x000005eb 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) + 0x000005d9 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) .ARM.attributes - 0x0000060b 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + 0x000005f9 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtend.o .ARM.attributes - 0x0000063d 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) - .ARM.attributes - 0x0000065d 0x32 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtend.o - .ARM.attributes - 0x0000068f 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o + 0x0000062b 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtn.o .comment 0x00000000 0x46 .comment 0x00000000 0x46 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtbegin.o @@ -3458,13 +3124,11 @@ LOAD /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a .comment 0x00000046 0x24 build/debug/stm32h7xx_hal_pwr_ex.o .comment 0x00000046 0x24 build/debug/stm32h7xx_hal_rcc.o .comment 0x00000046 0x24 build/debug/stm32h7xx_hal_rcc_ex.o - .comment 0x00000046 0x24 build/debug/stm32h7xx_hal_sd.o .comment 0x00000046 0x24 build/debug/stm32h7xx_hal_sdram.o .comment 0x00000046 0x24 build/debug/stm32h7xx_hal_uart.o .comment 0x00000046 0x24 build/debug/stm32h7xx_hal_uart_ex.o .comment 0x00000046 0x24 build/debug/stm32h7xx_it.o .comment 0x00000046 0x24 build/debug/stm32h7xx_ll_fmc.o - .comment 0x00000046 0x24 build/debug/stm32h7xx_ll_sdmmc.o .comment 0x00000046 0x24 build/debug/stm32h7xx_ll_usb.o .comment 0x00000046 0x24 build/debug/system_stm32h7xx.o .comment 0x00000046 0x24 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) @@ -3473,362 +3137,338 @@ LOAD /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a .comment 0x00000046 0x24 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) .comment 0x00000046 0x24 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/crtend.o -.debug_info 0x00000000 0x2d6f3 - .debug_info 0x00000000 0x3a51 build/debug/main.o - .debug_info 0x00003a51 0x14ef build/debug/stm32h7xx_hal.o - .debug_info 0x00004f40 0x12fc build/debug/stm32h7xx_hal_cortex.o - .debug_info 0x0000623c 0x600 build/debug/stm32h7xx_hal_crc.o - .debug_info 0x0000683c 0x352 build/debug/stm32h7xx_hal_crc_ex.o - .debug_info 0x00006b8e 0x3275 build/debug/stm32h7xx_hal_fdcan.o - .debug_info 0x00009e03 0xb76 build/debug/stm32h7xx_hal_gpio.o - .debug_info 0x0000a979 0x44f5 build/debug/stm32h7xx_hal_i2c.o - .debug_info 0x0000ee6e 0xc81 build/debug/stm32h7xx_hal_i2c_ex.o - .debug_info 0x0000faef 0x1504 build/debug/stm32h7xx_hal_ltdc.o - .debug_info 0x00010ff3 0x3ebc build/debug/stm32h7xx_hal_msp.o - .debug_info 0x00014eaf 0x1c4f build/debug/stm32h7xx_hal_pcd.o - .debug_info 0x00016afe 0xa1a build/debug/stm32h7xx_hal_pcd_ex.o - .debug_info 0x00017518 0x107c build/debug/stm32h7xx_hal_pwr_ex.o - .debug_info 0x00018594 0x1174 build/debug/stm32h7xx_hal_rcc.o - .debug_info 0x00019708 0x1986 build/debug/stm32h7xx_hal_rcc_ex.o - .debug_info 0x0001b08e 0x263b build/debug/stm32h7xx_hal_sd.o - .debug_info 0x0001d6c9 0x132d build/debug/stm32h7xx_hal_sdram.o - .debug_info 0x0001e9f6 0x657c build/debug/stm32h7xx_hal_uart.o - .debug_info 0x00024f72 0x1226 build/debug/stm32h7xx_hal_uart_ex.o - .debug_info 0x00026198 0x1327 build/debug/stm32h7xx_it.o - .debug_info 0x000274bf 0xcbe build/debug/stm32h7xx_ll_fmc.o - .debug_info 0x0002817d 0x1e7c build/debug/stm32h7xx_ll_sdmmc.o - .debug_info 0x00029ff9 0x1f0d build/debug/stm32h7xx_ll_usb.o - .debug_info 0x0002bf06 0xd5c build/debug/system_stm32h7xx.o - .debug_info 0x0002cc62 0x30 build/debug/startup_stm32h7a3xx.o - .debug_info 0x0002cc92 0xe0 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) - .debug_info 0x0002cd72 0x10b /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - .debug_info 0x0002ce7d 0x121 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - .debug_info 0x0002cf9e 0x24 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) - .debug_info 0x0002cfc2 0x6f5 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) - .debug_info 0x0002d6b7 0x3c /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) +.debug_info 0x00000000 0x28767 + .debug_info 0x00000000 0x343b build/debug/main.o + .debug_info 0x0000343b 0x14ef build/debug/stm32h7xx_hal.o + .debug_info 0x0000492a 0x12fc build/debug/stm32h7xx_hal_cortex.o + .debug_info 0x00005c26 0x600 build/debug/stm32h7xx_hal_crc.o + .debug_info 0x00006226 0x352 build/debug/stm32h7xx_hal_crc_ex.o + .debug_info 0x00006578 0x3275 build/debug/stm32h7xx_hal_fdcan.o + .debug_info 0x000097ed 0xb76 build/debug/stm32h7xx_hal_gpio.o + .debug_info 0x0000a363 0x44f5 build/debug/stm32h7xx_hal_i2c.o + .debug_info 0x0000e858 0xc81 build/debug/stm32h7xx_hal_i2c_ex.o + .debug_info 0x0000f4d9 0x1504 build/debug/stm32h7xx_hal_ltdc.o + .debug_info 0x000109dd 0x39fd build/debug/stm32h7xx_hal_msp.o + .debug_info 0x000143da 0x1c4f build/debug/stm32h7xx_hal_pcd.o + .debug_info 0x00016029 0xa1a build/debug/stm32h7xx_hal_pcd_ex.o + .debug_info 0x00016a43 0x107c build/debug/stm32h7xx_hal_pwr_ex.o + .debug_info 0x00017abf 0x1174 build/debug/stm32h7xx_hal_rcc.o + .debug_info 0x00018c33 0x1986 build/debug/stm32h7xx_hal_rcc_ex.o + .debug_info 0x0001a5b9 0x132d build/debug/stm32h7xx_hal_sdram.o + .debug_info 0x0001b8e6 0x657c build/debug/stm32h7xx_hal_uart.o + .debug_info 0x00021e62 0x1226 build/debug/stm32h7xx_hal_uart_ex.o + .debug_info 0x00023088 0x1327 build/debug/stm32h7xx_it.o + .debug_info 0x000243af 0xcbe build/debug/stm32h7xx_ll_fmc.o + .debug_info 0x0002506d 0x1f0d build/debug/stm32h7xx_ll_usb.o + .debug_info 0x00026f7a 0xd5c build/debug/system_stm32h7xx.o + .debug_info 0x00027cd6 0x30 build/debug/startup_stm32h7a3xx.o + .debug_info 0x00027d06 0xe0 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + .debug_info 0x00027de6 0x10b /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + .debug_info 0x00027ef1 0x121 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + .debug_info 0x00028012 0x24 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) + .debug_info 0x00028036 0x6f5 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + .debug_info 0x0002872b 0x3c /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) -.debug_abbrev 0x00000000 0x43f0 - .debug_abbrev 0x00000000 0x35a build/debug/main.o - .debug_abbrev 0x0000035a 0x2b6 build/debug/stm32h7xx_hal.o - .debug_abbrev 0x00000610 0x3ad build/debug/stm32h7xx_hal_cortex.o - .debug_abbrev 0x000009bd 0x223 build/debug/stm32h7xx_hal_crc.o - .debug_abbrev 0x00000be0 0x16d build/debug/stm32h7xx_hal_crc_ex.o - .debug_abbrev 0x00000d4d 0x2be build/debug/stm32h7xx_hal_fdcan.o - .debug_abbrev 0x0000100b 0x251 build/debug/stm32h7xx_hal_gpio.o - .debug_abbrev 0x0000125c 0x296 build/debug/stm32h7xx_hal_i2c.o - .debug_abbrev 0x000014f2 0x1f5 build/debug/stm32h7xx_hal_i2c_ex.o - .debug_abbrev 0x000016e7 0x24a build/debug/stm32h7xx_hal_ltdc.o - .debug_abbrev 0x00001931 0x302 build/debug/stm32h7xx_hal_msp.o - .debug_abbrev 0x00001c33 0x2fa build/debug/stm32h7xx_hal_pcd.o - .debug_abbrev 0x00001f2d 0x2ad build/debug/stm32h7xx_hal_pcd_ex.o - .debug_abbrev 0x000021da 0x2b7 build/debug/stm32h7xx_hal_pwr_ex.o - .debug_abbrev 0x00002491 0x2a8 build/debug/stm32h7xx_hal_rcc.o - .debug_abbrev 0x00002739 0x293 build/debug/stm32h7xx_hal_rcc_ex.o - .debug_abbrev 0x000029cc 0x29f build/debug/stm32h7xx_hal_sd.o - .debug_abbrev 0x00002c6b 0x20e build/debug/stm32h7xx_hal_sdram.o - .debug_abbrev 0x00002e79 0x38b build/debug/stm32h7xx_hal_uart.o - .debug_abbrev 0x00003204 0x343 build/debug/stm32h7xx_hal_uart_ex.o - .debug_abbrev 0x00003547 0x21a build/debug/stm32h7xx_it.o - .debug_abbrev 0x00003761 0x1c4 build/debug/stm32h7xx_ll_fmc.o - .debug_abbrev 0x00003925 0x249 build/debug/stm32h7xx_ll_sdmmc.o - .debug_abbrev 0x00003b6e 0x329 build/debug/stm32h7xx_ll_usb.o - .debug_abbrev 0x00003e97 0x169 build/debug/system_stm32h7xx.o - .debug_abbrev 0x00004000 0x24 build/debug/startup_stm32h7a3xx.o - .debug_abbrev 0x00004024 0x9e /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) - .debug_abbrev 0x000040c2 0xc9 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - .debug_abbrev 0x0000418b 0xc1 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - .debug_abbrev 0x0000424c 0x14 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) - .debug_abbrev 0x00004260 0x16a /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) - .debug_abbrev 0x000043ca 0x26 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) +.debug_abbrev 0x00000000 0x3ed6 + .debug_abbrev 0x00000000 0x33d build/debug/main.o + .debug_abbrev 0x0000033d 0x2b6 build/debug/stm32h7xx_hal.o + .debug_abbrev 0x000005f3 0x3ad build/debug/stm32h7xx_hal_cortex.o + .debug_abbrev 0x000009a0 0x223 build/debug/stm32h7xx_hal_crc.o + .debug_abbrev 0x00000bc3 0x16d build/debug/stm32h7xx_hal_crc_ex.o + .debug_abbrev 0x00000d30 0x2be build/debug/stm32h7xx_hal_fdcan.o + .debug_abbrev 0x00000fee 0x251 build/debug/stm32h7xx_hal_gpio.o + .debug_abbrev 0x0000123f 0x296 build/debug/stm32h7xx_hal_i2c.o + .debug_abbrev 0x000014d5 0x1f5 build/debug/stm32h7xx_hal_i2c_ex.o + .debug_abbrev 0x000016ca 0x24a build/debug/stm32h7xx_hal_ltdc.o + .debug_abbrev 0x00001914 0x2ed build/debug/stm32h7xx_hal_msp.o + .debug_abbrev 0x00001c01 0x2fa build/debug/stm32h7xx_hal_pcd.o + .debug_abbrev 0x00001efb 0x2ad build/debug/stm32h7xx_hal_pcd_ex.o + .debug_abbrev 0x000021a8 0x2b7 build/debug/stm32h7xx_hal_pwr_ex.o + .debug_abbrev 0x0000245f 0x2a8 build/debug/stm32h7xx_hal_rcc.o + .debug_abbrev 0x00002707 0x293 build/debug/stm32h7xx_hal_rcc_ex.o + .debug_abbrev 0x0000299a 0x20e build/debug/stm32h7xx_hal_sdram.o + .debug_abbrev 0x00002ba8 0x38b build/debug/stm32h7xx_hal_uart.o + .debug_abbrev 0x00002f33 0x343 build/debug/stm32h7xx_hal_uart_ex.o + .debug_abbrev 0x00003276 0x21a build/debug/stm32h7xx_it.o + .debug_abbrev 0x00003490 0x1c4 build/debug/stm32h7xx_ll_fmc.o + .debug_abbrev 0x00003654 0x329 build/debug/stm32h7xx_ll_usb.o + .debug_abbrev 0x0000397d 0x169 build/debug/system_stm32h7xx.o + .debug_abbrev 0x00003ae6 0x24 build/debug/startup_stm32h7a3xx.o + .debug_abbrev 0x00003b0a 0x9e /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + .debug_abbrev 0x00003ba8 0xc9 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + .debug_abbrev 0x00003c71 0xc1 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + .debug_abbrev 0x00003d32 0x14 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) + .debug_abbrev 0x00003d46 0x16a /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + .debug_abbrev 0x00003eb0 0x26 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) -.debug_loclists - 0x00000000 0x15376 - .debug_loclists - 0x00000000 0x21 build/debug/main.o - .debug_loclists - 0x00000021 0x2d8 build/debug/stm32h7xx_hal.o - .debug_loclists - 0x000002f9 0x50a build/debug/stm32h7xx_hal_cortex.o - .debug_loclists - 0x00000803 0x3f6 build/debug/stm32h7xx_hal_crc.o - .debug_loclists - 0x00000bf9 0x1a3 build/debug/stm32h7xx_hal_crc_ex.o - .debug_loclists - 0x00000d9c 0x275a build/debug/stm32h7xx_hal_fdcan.o - .debug_loclists - 0x000034f6 0x2a0 build/debug/stm32h7xx_hal_gpio.o - .debug_loclists - 0x00003796 0x3c87 build/debug/stm32h7xx_hal_i2c.o - .debug_loclists - 0x0000741d 0x129 build/debug/stm32h7xx_hal_i2c_ex.o - .debug_loclists - 0x00007546 0x116c build/debug/stm32h7xx_hal_ltdc.o - .debug_loclists - 0x000086b2 0x2e0 build/debug/stm32h7xx_hal_msp.o - .debug_loclists - 0x00008992 0xd74 build/debug/stm32h7xx_hal_pcd.o - .debug_loclists - 0x00009706 0x18e build/debug/stm32h7xx_hal_pcd_ex.o - .debug_loclists - 0x00009894 0x2b2 build/debug/stm32h7xx_hal_pwr_ex.o - .debug_loclists - 0x00009b46 0x621 build/debug/stm32h7xx_hal_rcc.o - .debug_loclists - 0x0000a167 0x1426 build/debug/stm32h7xx_hal_rcc_ex.o - .debug_loclists - 0x0000b58d 0x1877 build/debug/stm32h7xx_hal_sd.o - .debug_loclists - 0x0000ce04 0xa76 build/debug/stm32h7xx_hal_sdram.o - .debug_loclists - 0x0000d87a 0x38d3 build/debug/stm32h7xx_hal_uart.o - .debug_loclists - 0x0001114d 0x7dc build/debug/stm32h7xx_hal_uart_ex.o - .debug_loclists - 0x00011929 0x578 build/debug/stm32h7xx_ll_fmc.o - .debug_loclists - 0x00011ea1 0xed2 build/debug/stm32h7xx_ll_sdmmc.o - .debug_loclists - 0x00012d73 0x18ca build/debug/stm32h7xx_ll_usb.o - .debug_loclists - 0x0001463d 0x120 build/debug/system_stm32h7xx.o - .debug_loclists - 0x0001475d 0x4d /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) - .debug_loclists - 0x000147aa 0x54 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - .debug_loclists - 0x000147fe 0xad /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - .debug_loclists - 0x000148ab 0xacb /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) - -.debug_aranges 0x00000000 0x1bf0 +.debug_aranges 0x00000000 0x1890 .debug_aranges - 0x00000000 0x88 build/debug/main.o + 0x00000000 0x78 build/debug/main.o .debug_aranges - 0x00000088 0x1a0 build/debug/stm32h7xx_hal.o + 0x00000078 0x1a0 build/debug/stm32h7xx_hal.o .debug_aranges - 0x00000228 0xf8 build/debug/stm32h7xx_hal_cortex.o + 0x00000218 0xf8 build/debug/stm32h7xx_hal_cortex.o .debug_aranges - 0x00000320 0x60 build/debug/stm32h7xx_hal_crc.o + 0x00000310 0x60 build/debug/stm32h7xx_hal_crc.o .debug_aranges - 0x00000380 0x30 build/debug/stm32h7xx_hal_crc_ex.o + 0x00000370 0x30 build/debug/stm32h7xx_hal_crc_ex.o .debug_aranges - 0x000003b0 0x338 build/debug/stm32h7xx_hal_fdcan.o + 0x000003a0 0x338 build/debug/stm32h7xx_hal_fdcan.o .debug_aranges - 0x000006e8 0x58 build/debug/stm32h7xx_hal_gpio.o + 0x000006d8 0x58 build/debug/stm32h7xx_hal_gpio.o .debug_aranges - 0x00000740 0x2a0 build/debug/stm32h7xx_hal_i2c.o + 0x00000730 0x2a0 build/debug/stm32h7xx_hal_i2c.o .debug_aranges - 0x000009e0 0x48 build/debug/stm32h7xx_hal_i2c_ex.o + 0x000009d0 0x48 build/debug/stm32h7xx_hal_i2c_ex.o .debug_aranges - 0x00000a28 0x158 build/debug/stm32h7xx_hal_ltdc.o + 0x00000a18 0x158 build/debug/stm32h7xx_hal_ltdc.o .debug_aranges - 0x00000b80 0xb0 build/debug/stm32h7xx_hal_msp.o + 0x00000b70 0xa0 build/debug/stm32h7xx_hal_msp.o .debug_aranges - 0x00000c30 0x140 build/debug/stm32h7xx_hal_pcd.o + 0x00000c10 0x140 build/debug/stm32h7xx_hal_pcd.o .debug_aranges - 0x00000d70 0x60 build/debug/stm32h7xx_hal_pcd_ex.o + 0x00000d50 0x60 build/debug/stm32h7xx_hal_pcd_ex.o .debug_aranges - 0x00000dd0 0x188 build/debug/stm32h7xx_hal_pwr_ex.o + 0x00000db0 0x188 build/debug/stm32h7xx_hal_pwr_ex.o .debug_aranges - 0x00000f58 0x88 build/debug/stm32h7xx_hal_rcc.o + 0x00000f38 0x88 build/debug/stm32h7xx_hal_rcc.o .debug_aranges - 0x00000fe0 0xf0 build/debug/stm32h7xx_hal_rcc_ex.o + 0x00000fc0 0xf0 build/debug/stm32h7xx_hal_rcc_ex.o .debug_aranges - 0x000010d0 0x170 build/debug/stm32h7xx_hal_sd.o + 0x000010b0 0xe8 build/debug/stm32h7xx_hal_sdram.o .debug_aranges - 0x00001240 0xe8 build/debug/stm32h7xx_hal_sdram.o + 0x00001198 0x248 build/debug/stm32h7xx_hal_uart.o .debug_aranges - 0x00001328 0x248 build/debug/stm32h7xx_hal_uart.o + 0x000013e0 0xa8 build/debug/stm32h7xx_hal_uart_ex.o .debug_aranges - 0x00001570 0xa8 build/debug/stm32h7xx_hal_uart_ex.o + 0x00001488 0x88 build/debug/stm32h7xx_it.o .debug_aranges - 0x00001618 0x88 build/debug/stm32h7xx_it.o + 0x00001510 0xc8 build/debug/stm32h7xx_ll_fmc.o .debug_aranges - 0x000016a0 0xc8 build/debug/stm32h7xx_ll_fmc.o + 0x000015d8 0x1a0 build/debug/stm32h7xx_ll_usb.o .debug_aranges - 0x00001768 0x1d0 build/debug/stm32h7xx_ll_sdmmc.o + 0x00001778 0x30 build/debug/system_stm32h7xx.o .debug_aranges - 0x00001938 0x1a0 build/debug/stm32h7xx_ll_usb.o + 0x000017a8 0x28 build/debug/startup_stm32h7a3xx.o .debug_aranges - 0x00001ad8 0x30 build/debug/system_stm32h7xx.o + 0x000017d0 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) .debug_aranges - 0x00001b08 0x28 build/debug/startup_stm32h7a3xx.o + 0x000017f0 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) .debug_aranges - 0x00001b30 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + 0x00001810 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) .debug_aranges - 0x00001b50 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + 0x00001830 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) .debug_aranges - 0x00001b70 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + 0x00001850 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) .debug_aranges - 0x00001b90 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) - .debug_aranges - 0x00001bb0 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) - .debug_aranges - 0x00001bd0 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) + 0x00001870 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) .debug_rnglists - 0x00000000 0x15fc + 0x00000000 0x1367 .debug_rnglists - 0x00000000 0x64 build/debug/main.o + 0x00000000 0x59 build/debug/main.o .debug_rnglists - 0x00000064 0x135 build/debug/stm32h7xx_hal.o + 0x00000059 0x135 build/debug/stm32h7xx_hal.o .debug_rnglists - 0x00000199 0xb5 build/debug/stm32h7xx_hal_cortex.o + 0x0000018e 0xb5 build/debug/stm32h7xx_hal_cortex.o .debug_rnglists - 0x0000024e 0x45 build/debug/stm32h7xx_hal_crc.o + 0x00000243 0x45 build/debug/stm32h7xx_hal_crc.o .debug_rnglists - 0x00000293 0x20 build/debug/stm32h7xx_hal_crc_ex.o + 0x00000288 0x20 build/debug/stm32h7xx_hal_crc_ex.o .debug_rnglists - 0x000002b3 0x29a build/debug/stm32h7xx_hal_fdcan.o + 0x000002a8 0x29a build/debug/stm32h7xx_hal_fdcan.o .debug_rnglists - 0x0000054d 0x3f build/debug/stm32h7xx_hal_gpio.o + 0x00000542 0x3f build/debug/stm32h7xx_hal_gpio.o .debug_rnglists - 0x0000058c 0x21e build/debug/stm32h7xx_hal_i2c.o + 0x00000581 0x21e build/debug/stm32h7xx_hal_i2c.o .debug_rnglists - 0x000007aa 0x31 build/debug/stm32h7xx_hal_i2c_ex.o + 0x0000079f 0x31 build/debug/stm32h7xx_hal_i2c_ex.o .debug_rnglists - 0x000007db 0x103 build/debug/stm32h7xx_hal_ltdc.o + 0x000007d0 0x103 build/debug/stm32h7xx_hal_ltdc.o .debug_rnglists - 0x000008de 0x87 build/debug/stm32h7xx_hal_msp.o + 0x000008d3 0x7a build/debug/stm32h7xx_hal_msp.o .debug_rnglists - 0x00000965 0xf1 build/debug/stm32h7xx_hal_pcd.o + 0x0000094d 0xf1 build/debug/stm32h7xx_hal_pcd.o .debug_rnglists - 0x00000a56 0x44 build/debug/stm32h7xx_hal_pcd_ex.o + 0x00000a3e 0x44 build/debug/stm32h7xx_hal_pcd_ex.o .debug_rnglists - 0x00000a9a 0x156 build/debug/stm32h7xx_hal_pwr_ex.o + 0x00000a82 0x156 build/debug/stm32h7xx_hal_pwr_ex.o .debug_rnglists - 0x00000bf0 0xa9 build/debug/stm32h7xx_hal_rcc.o + 0x00000bd8 0xa9 build/debug/stm32h7xx_hal_rcc.o .debug_rnglists - 0x00000c99 0xb9 build/debug/stm32h7xx_hal_rcc_ex.o + 0x00000c81 0xb9 build/debug/stm32h7xx_hal_rcc_ex.o .debug_rnglists - 0x00000d52 0x123 build/debug/stm32h7xx_hal_sd.o + 0x00000d3a 0xa9 build/debug/stm32h7xx_hal_sdram.o .debug_rnglists - 0x00000e75 0xa9 build/debug/stm32h7xx_hal_sdram.o + 0x00000de3 0x1cb build/debug/stm32h7xx_hal_uart.o .debug_rnglists - 0x00000f1e 0x1cb build/debug/stm32h7xx_hal_uart.o + 0x00000fae 0x88 build/debug/stm32h7xx_hal_uart_ex.o .debug_rnglists - 0x000010e9 0x88 build/debug/stm32h7xx_hal_uart_ex.o + 0x00001036 0x61 build/debug/stm32h7xx_it.o .debug_rnglists - 0x00001171 0x61 build/debug/stm32h7xx_it.o + 0x00001097 0x93 build/debug/stm32h7xx_ll_fmc.o .debug_rnglists - 0x000011d2 0x93 build/debug/stm32h7xx_ll_fmc.o + 0x0000112a 0x141 build/debug/stm32h7xx_ll_usb.o .debug_rnglists - 0x00001265 0x15a build/debug/stm32h7xx_ll_sdmmc.o + 0x0000126b 0x21 build/debug/system_stm32h7xx.o .debug_rnglists - 0x000013bf 0x141 build/debug/stm32h7xx_ll_usb.o + 0x0000128c 0x19 build/debug/startup_stm32h7a3xx.o .debug_rnglists - 0x00001500 0x21 build/debug/system_stm32h7xx.o + 0x000012a5 0x13 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) .debug_rnglists - 0x00001521 0x19 build/debug/startup_stm32h7a3xx.o + 0x000012b8 0x13 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) .debug_rnglists - 0x0000153a 0x13 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + 0x000012cb 0x13 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) .debug_rnglists - 0x0000154d 0x13 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - .debug_rnglists - 0x00001560 0x13 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - .debug_rnglists - 0x00001573 0x89 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + 0x000012de 0x89 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) -.debug_line 0x00000000 0x1fcee - .debug_line 0x00000000 0xc7b build/debug/main.o - .debug_line 0x00000c7b 0x88f build/debug/stm32h7xx_hal.o - .debug_line 0x0000150a 0x7d3 build/debug/stm32h7xx_hal_cortex.o - .debug_line 0x00001cdd 0x519 build/debug/stm32h7xx_hal_crc.o - .debug_line 0x000021f6 0x24b build/debug/stm32h7xx_hal_crc_ex.o - .debug_line 0x00002441 0x3338 build/debug/stm32h7xx_hal_fdcan.o - .debug_line 0x00005779 0x6af build/debug/stm32h7xx_hal_gpio.o - .debug_line 0x00005e28 0x4fdb build/debug/stm32h7xx_hal_i2c.o - .debug_line 0x0000ae03 0x367 build/debug/stm32h7xx_hal_i2c_ex.o - .debug_line 0x0000b16a 0x11af build/debug/stm32h7xx_hal_ltdc.o - .debug_line 0x0000c319 0xc2a build/debug/stm32h7xx_hal_msp.o - .debug_line 0x0000cf43 0x13d7 build/debug/stm32h7xx_hal_pcd.o - .debug_line 0x0000e31a 0x458 build/debug/stm32h7xx_hal_pcd_ex.o - .debug_line 0x0000e772 0xae4 build/debug/stm32h7xx_hal_pwr_ex.o - .debug_line 0x0000f256 0x1337 build/debug/stm32h7xx_hal_rcc.o - .debug_line 0x0001058d 0x1e24 build/debug/stm32h7xx_hal_rcc_ex.o - .debug_line 0x000123b1 0x2982 build/debug/stm32h7xx_hal_sd.o - .debug_line 0x00014d33 0x9d9 build/debug/stm32h7xx_hal_sdram.o - .debug_line 0x0001570c 0x50e3 build/debug/stm32h7xx_hal_uart.o - .debug_line 0x0001a7ef 0xa10 build/debug/stm32h7xx_hal_uart_ex.o - .debug_line 0x0001b1ff 0x2f7 build/debug/stm32h7xx_it.o - .debug_line 0x0001b4f6 0x6af build/debug/stm32h7xx_ll_fmc.o - .debug_line 0x0001bba5 0x1424 build/debug/stm32h7xx_ll_sdmmc.o - .debug_line 0x0001cfc9 0x1e92 build/debug/stm32h7xx_ll_usb.o - .debug_line 0x0001ee5b 0x3ef build/debug/system_stm32h7xx.o - .debug_line 0x0001f24a 0x77 build/debug/startup_stm32h7a3xx.o - .debug_line 0x0001f2c1 0x12d /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) - .debug_line 0x0001f3ee 0xff /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - .debug_line 0x0001f4ed 0x185 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - .debug_line 0x0001f672 0x4e /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) - .debug_line 0x0001f6c0 0x5e4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) - .debug_line 0x0001fca4 0x4a /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) +.debug_line 0x00000000 0x1bdff + .debug_line 0x00000000 0xbcb build/debug/main.o + .debug_line 0x00000bcb 0x88f build/debug/stm32h7xx_hal.o + .debug_line 0x0000145a 0x7d3 build/debug/stm32h7xx_hal_cortex.o + .debug_line 0x00001c2d 0x519 build/debug/stm32h7xx_hal_crc.o + .debug_line 0x00002146 0x24b build/debug/stm32h7xx_hal_crc_ex.o + .debug_line 0x00002391 0x3338 build/debug/stm32h7xx_hal_fdcan.o + .debug_line 0x000056c9 0x6af build/debug/stm32h7xx_hal_gpio.o + .debug_line 0x00005d78 0x4fdb build/debug/stm32h7xx_hal_i2c.o + .debug_line 0x0000ad53 0x367 build/debug/stm32h7xx_hal_i2c_ex.o + .debug_line 0x0000b0ba 0x11af build/debug/stm32h7xx_hal_ltdc.o + .debug_line 0x0000c269 0xb91 build/debug/stm32h7xx_hal_msp.o + .debug_line 0x0000cdfa 0x13d7 build/debug/stm32h7xx_hal_pcd.o + .debug_line 0x0000e1d1 0x458 build/debug/stm32h7xx_hal_pcd_ex.o + .debug_line 0x0000e629 0xae4 build/debug/stm32h7xx_hal_pwr_ex.o + .debug_line 0x0000f10d 0x1337 build/debug/stm32h7xx_hal_rcc.o + .debug_line 0x00010444 0x1e24 build/debug/stm32h7xx_hal_rcc_ex.o + .debug_line 0x00012268 0x9d9 build/debug/stm32h7xx_hal_sdram.o + .debug_line 0x00012c41 0x50e3 build/debug/stm32h7xx_hal_uart.o + .debug_line 0x00017d24 0xa10 build/debug/stm32h7xx_hal_uart_ex.o + .debug_line 0x00018734 0x2f7 build/debug/stm32h7xx_it.o + .debug_line 0x00018a2b 0x6af build/debug/stm32h7xx_ll_fmc.o + .debug_line 0x000190da 0x1e92 build/debug/stm32h7xx_ll_usb.o + .debug_line 0x0001af6c 0x3ef build/debug/system_stm32h7xx.o + .debug_line 0x0001b35b 0x77 build/debug/startup_stm32h7a3xx.o + .debug_line 0x0001b3d2 0x12d /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + .debug_line 0x0001b4ff 0xff /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + .debug_line 0x0001b5fe 0x185 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + .debug_line 0x0001b783 0x4e /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) + .debug_line 0x0001b7d1 0x5e4 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + .debug_line 0x0001bdb5 0x4a /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) -.debug_str 0x00000000 0xa987 - .debug_str 0x00000000 0xa987 build/debug/main.o - 0x274a (size before relaxing) - .debug_str 0x0000a987 0x1456 build/debug/stm32h7xx_hal.o - .debug_str 0x0000a987 0x1029 build/debug/stm32h7xx_hal_cortex.o - .debug_str 0x0000a987 0x47c build/debug/stm32h7xx_hal_crc.o - .debug_str 0x0000a987 0x422 build/debug/stm32h7xx_hal_crc_ex.o - .debug_str 0x0000a987 0x1d96 build/debug/stm32h7xx_hal_fdcan.o - .debug_str 0x0000a987 0x6ac build/debug/stm32h7xx_hal_gpio.o - .debug_str 0x0000a987 0x1170 build/debug/stm32h7xx_hal_i2c.o - .debug_str 0x0000a987 0xb03 build/debug/stm32h7xx_hal_i2c_ex.o - .debug_str 0x0000a987 0x9c2 build/debug/stm32h7xx_hal_ltdc.o - .debug_str 0x0000a987 0x2c21 build/debug/stm32h7xx_hal_msp.o - .debug_str 0x0000a987 0xe36 build/debug/stm32h7xx_hal_pcd.o - .debug_str 0x0000a987 0x822 build/debug/stm32h7xx_hal_pcd_ex.o - .debug_str 0x0000a987 0xae5 build/debug/stm32h7xx_hal_pwr_ex.o - .debug_str 0x0000a987 0xa36 build/debug/stm32h7xx_hal_rcc.o - .debug_str 0x0000a987 0xef5 build/debug/stm32h7xx_hal_rcc_ex.o - .debug_str 0x0000a987 0x1016 build/debug/stm32h7xx_hal_sd.o - .debug_str 0x0000a987 0xb9e build/debug/stm32h7xx_hal_sdram.o - .debug_str 0x0000a987 0x14be build/debug/stm32h7xx_hal_uart.o - .debug_str 0x0000a987 0xb91 build/debug/stm32h7xx_hal_uart_ex.o - .debug_str 0x0000a987 0xf04 build/debug/stm32h7xx_it.o - .debug_str 0x0000a987 0x8a3 build/debug/stm32h7xx_ll_fmc.o - .debug_str 0x0000a987 0x935 build/debug/stm32h7xx_ll_sdmmc.o - .debug_str 0x0000a987 0xd7e build/debug/stm32h7xx_ll_usb.o - .debug_str 0x0000a987 0x74d build/debug/system_stm32h7xx.o - .debug_str 0x0000a987 0x6d build/debug/startup_stm32h7a3xx.o - .debug_str 0x0000a987 0x1e2 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) - .debug_str 0x0000a987 0x243 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - .debug_str 0x0000a987 0x200 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - .debug_str 0x0000a987 0xd2 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) - .debug_str 0x0000a987 0x6ae /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) - .debug_str 0x0000a987 0xf2 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) +.debug_str 0x00000000 0x99c5 + .debug_str 0x00000000 0x99c5 build/debug/main.o + 0x2226 (size before relaxing) + .debug_str 0x000099c5 0x1456 build/debug/stm32h7xx_hal.o + .debug_str 0x000099c5 0x1029 build/debug/stm32h7xx_hal_cortex.o + .debug_str 0x000099c5 0x47c build/debug/stm32h7xx_hal_crc.o + .debug_str 0x000099c5 0x422 build/debug/stm32h7xx_hal_crc_ex.o + .debug_str 0x000099c5 0x1d96 build/debug/stm32h7xx_hal_fdcan.o + .debug_str 0x000099c5 0x6ac build/debug/stm32h7xx_hal_gpio.o + .debug_str 0x000099c5 0x1170 build/debug/stm32h7xx_hal_i2c.o + .debug_str 0x000099c5 0xb03 build/debug/stm32h7xx_hal_i2c_ex.o + .debug_str 0x000099c5 0x9c2 build/debug/stm32h7xx_hal_ltdc.o + .debug_str 0x000099c5 0x29d3 build/debug/stm32h7xx_hal_msp.o + .debug_str 0x000099c5 0xe36 build/debug/stm32h7xx_hal_pcd.o + .debug_str 0x000099c5 0x822 build/debug/stm32h7xx_hal_pcd_ex.o + .debug_str 0x000099c5 0xae5 build/debug/stm32h7xx_hal_pwr_ex.o + .debug_str 0x000099c5 0xa36 build/debug/stm32h7xx_hal_rcc.o + .debug_str 0x000099c5 0xef5 build/debug/stm32h7xx_hal_rcc_ex.o + .debug_str 0x000099c5 0xb9e build/debug/stm32h7xx_hal_sdram.o + .debug_str 0x000099c5 0x14be build/debug/stm32h7xx_hal_uart.o + .debug_str 0x000099c5 0xb91 build/debug/stm32h7xx_hal_uart_ex.o + .debug_str 0x000099c5 0xf04 build/debug/stm32h7xx_it.o + .debug_str 0x000099c5 0x8a3 build/debug/stm32h7xx_ll_fmc.o + .debug_str 0x000099c5 0xd7e build/debug/stm32h7xx_ll_usb.o + .debug_str 0x000099c5 0x74d build/debug/system_stm32h7xx.o + .debug_str 0x000099c5 0x6d build/debug/startup_stm32h7a3xx.o + .debug_str 0x000099c5 0x1e2 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + .debug_str 0x000099c5 0x243 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + .debug_str 0x000099c5 0x200 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + .debug_str 0x000099c5 0xd2 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) + .debug_str 0x000099c5 0x6ae /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + .debug_str 0x000099c5 0xf2 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_dvmd_tls.o) -.debug_frame 0x00000000 0x4a78 - .debug_frame 0x00000000 0x190 build/debug/main.o - .debug_frame 0x00000190 0x370 build/debug/stm32h7xx_hal.o - .debug_frame 0x00000500 0x214 build/debug/stm32h7xx_hal_cortex.o - .debug_frame 0x00000714 0xec build/debug/stm32h7xx_hal_crc.o - .debug_frame 0x00000800 0x58 build/debug/stm32h7xx_hal_crc_ex.o - .debug_frame 0x00000858 0x7a4 build/debug/stm32h7xx_hal_fdcan.o - .debug_frame 0x00000ffc 0xd4 build/debug/stm32h7xx_hal_gpio.o - .debug_frame 0x000010d0 0x98c build/debug/stm32h7xx_hal_i2c.o - .debug_frame 0x00001a5c 0x80 build/debug/stm32h7xx_hal_i2c_ex.o - .debug_frame 0x00001adc 0x3c4 build/debug/stm32h7xx_hal_ltdc.o - .debug_frame 0x00001ea0 0x23c build/debug/stm32h7xx_hal_msp.o - .debug_frame 0x000020dc 0x378 build/debug/stm32h7xx_hal_pcd.o - .debug_frame 0x00002454 0xb8 build/debug/stm32h7xx_hal_pcd_ex.o - .debug_frame 0x0000250c 0x354 build/debug/stm32h7xx_hal_pwr_ex.o - .debug_frame 0x00002860 0x184 build/debug/stm32h7xx_hal_rcc.o - .debug_frame 0x000029e4 0x274 build/debug/stm32h7xx_hal_rcc_ex.o - .debug_frame 0x00002c58 0x4c0 build/debug/stm32h7xx_hal_sd.o - .debug_frame 0x00003118 0x284 build/debug/stm32h7xx_hal_sdram.o - .debug_frame 0x0000339c 0x680 build/debug/stm32h7xx_hal_uart.o - .debug_frame 0x00003a1c 0x1c8 build/debug/stm32h7xx_hal_uart_ex.o - .debug_frame 0x00003be4 0x120 build/debug/stm32h7xx_it.o - .debug_frame 0x00003d04 0x1d8 build/debug/stm32h7xx_ll_fmc.o - .debug_frame 0x00003edc 0x5e0 build/debug/stm32h7xx_ll_sdmmc.o - .debug_frame 0x000044bc 0x498 build/debug/stm32h7xx_ll_usb.o - .debug_frame 0x00004954 0x50 build/debug/system_stm32h7xx.o - .debug_frame 0x000049a4 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) - .debug_frame 0x000049c4 0x2c /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) - .debug_frame 0x000049f0 0x28 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) - .debug_frame 0x00004a18 0x2c /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) - .debug_frame 0x00004a44 0x34 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) +.debug_frame 0x00000000 0x3f68 + .debug_frame 0x00000000 0x15c build/debug/main.o + .debug_frame 0x0000015c 0x370 build/debug/stm32h7xx_hal.o + .debug_frame 0x000004cc 0x214 build/debug/stm32h7xx_hal_cortex.o + .debug_frame 0x000006e0 0xec build/debug/stm32h7xx_hal_crc.o + .debug_frame 0x000007cc 0x58 build/debug/stm32h7xx_hal_crc_ex.o + .debug_frame 0x00000824 0x7a4 build/debug/stm32h7xx_hal_fdcan.o + .debug_frame 0x00000fc8 0xd4 build/debug/stm32h7xx_hal_gpio.o + .debug_frame 0x0000109c 0x98c build/debug/stm32h7xx_hal_i2c.o + .debug_frame 0x00001a28 0x80 build/debug/stm32h7xx_hal_i2c_ex.o + .debug_frame 0x00001aa8 0x3c4 build/debug/stm32h7xx_hal_ltdc.o + .debug_frame 0x00001e6c 0x200 build/debug/stm32h7xx_hal_msp.o + .debug_frame 0x0000206c 0x378 build/debug/stm32h7xx_hal_pcd.o + .debug_frame 0x000023e4 0xb8 build/debug/stm32h7xx_hal_pcd_ex.o + .debug_frame 0x0000249c 0x354 build/debug/stm32h7xx_hal_pwr_ex.o + .debug_frame 0x000027f0 0x184 build/debug/stm32h7xx_hal_rcc.o + .debug_frame 0x00002974 0x274 build/debug/stm32h7xx_hal_rcc_ex.o + .debug_frame 0x00002be8 0x284 build/debug/stm32h7xx_hal_sdram.o + .debug_frame 0x00002e6c 0x680 build/debug/stm32h7xx_hal_uart.o + .debug_frame 0x000034ec 0x1c8 build/debug/stm32h7xx_hal_uart_ex.o + .debug_frame 0x000036b4 0x120 build/debug/stm32h7xx_it.o + .debug_frame 0x000037d4 0x1d8 build/debug/stm32h7xx_ll_fmc.o + .debug_frame 0x000039ac 0x498 build/debug/stm32h7xx_ll_usb.o + .debug_frame 0x00003e44 0x50 build/debug/system_stm32h7xx.o + .debug_frame 0x00003e94 0x20 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + .debug_frame 0x00003eb4 0x2c /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + .debug_frame 0x00003ee0 0x28 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + .debug_frame 0x00003f08 0x2c /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_aeabi_uldivmod.o) + .debug_frame 0x00003f34 0x34 /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) + +.debug_loclists + 0x00000000 0x12ba1 + .debug_loclists + 0x00000000 0x2d8 build/debug/stm32h7xx_hal.o + .debug_loclists + 0x000002d8 0x50a build/debug/stm32h7xx_hal_cortex.o + .debug_loclists + 0x000007e2 0x3f6 build/debug/stm32h7xx_hal_crc.o + .debug_loclists + 0x00000bd8 0x1a3 build/debug/stm32h7xx_hal_crc_ex.o + .debug_loclists + 0x00000d7b 0x275a build/debug/stm32h7xx_hal_fdcan.o + .debug_loclists + 0x000034d5 0x2a0 build/debug/stm32h7xx_hal_gpio.o + .debug_loclists + 0x00003775 0x3c87 build/debug/stm32h7xx_hal_i2c.o + .debug_loclists + 0x000073fc 0x129 build/debug/stm32h7xx_hal_i2c_ex.o + .debug_loclists + 0x00007525 0x116c build/debug/stm32h7xx_hal_ltdc.o + .debug_loclists + 0x00008691 0x275 build/debug/stm32h7xx_hal_msp.o + .debug_loclists + 0x00008906 0xd74 build/debug/stm32h7xx_hal_pcd.o + .debug_loclists + 0x0000967a 0x18e build/debug/stm32h7xx_hal_pcd_ex.o + .debug_loclists + 0x00009808 0x2b2 build/debug/stm32h7xx_hal_pwr_ex.o + .debug_loclists + 0x00009aba 0x621 build/debug/stm32h7xx_hal_rcc.o + .debug_loclists + 0x0000a0db 0x1426 build/debug/stm32h7xx_hal_rcc_ex.o + .debug_loclists + 0x0000b501 0xa76 build/debug/stm32h7xx_hal_sdram.o + .debug_loclists + 0x0000bf77 0x38d3 build/debug/stm32h7xx_hal_uart.o + .debug_loclists + 0x0000f84a 0x7dc build/debug/stm32h7xx_hal_uart_ex.o + .debug_loclists + 0x00010026 0x578 build/debug/stm32h7xx_ll_fmc.o + .debug_loclists + 0x0001059e 0x18ca build/debug/stm32h7xx_ll_usb.o + .debug_loclists + 0x00011e68 0x120 build/debug/system_stm32h7xx.o + .debug_loclists + 0x00011f88 0x4d /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) + .debug_loclists + 0x00011fd5 0x54 /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-init.o) + .debug_loclists + 0x00012029 0xad /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memcpy-stub.o) + .debug_loclists + 0x000120d6 0xacb /usr/lib/gcc/arm-none-eabi/14.1.0/thumb/v7e-m+dp/hard/libgcc.a(_udivmoddi4.o) .debug_line_str 0x00000000 0x125 @@ -3894,9 +3534,6 @@ DMAMUX2_OVR_IRQHandler build/debug/startup_stm32h7a3x DTS_IRQHandler build/debug/startup_stm32h7a3xx.o DebugMon_Handler build/debug/stm32h7xx_it.o Default_Handler build/debug/startup_stm32h7a3xx.o -DelayBlock_Configure build/debug/stm32h7xx_ll_delayblock.o -DelayBlock_Disable build/debug/stm32h7xx_ll_delayblock.o -DelayBlock_Enable build/debug/stm32h7xx_ll_delayblock.o ECC_IRQHandler build/debug/startup_stm32h7a3xx.o EXTI0_IRQHandler build/debug/startup_stm32h7a3xx.o EXTI15_10_IRQHandler build/debug/startup_stm32h7a3xx.o @@ -4008,8 +3645,8 @@ HAL_DMA_UnRegisterCallback build/debug/stm32h7xx_hal_dma. HAL_DeInit build/debug/stm32h7xx_hal.o HAL_Delay build/debug/stm32h7xx_hal.o build/debug/stm32h7xx_ll_usb.o - build/debug/stm32h7xx_hal_sd.o build/debug/stm32h7xx_hal_pcd_ex.o + build/debug/main.o HAL_DisableCompensationCell build/debug/stm32h7xx_hal.o HAL_DisableDomain3DBGStandbyMode build/debug/stm32h7xx_hal.o HAL_DisableDomain3DBGStopMode build/debug/stm32h7xx_hal.o @@ -4173,10 +3810,8 @@ HAL_GetREVID build/debug/stm32h7xx_hal.o build/debug/stm32h7xx_hal_rcc_ex.o HAL_GetTick build/debug/stm32h7xx_hal.o build/debug/stm32h7xx_ll_fmc.o - build/debug/stm32h7xx_ll_delayblock.o build/debug/stm32h7xx_hal_uart_ex.o build/debug/stm32h7xx_hal_uart.o - build/debug/stm32h7xx_hal_sd.o build/debug/stm32h7xx_hal_rcc_ex.o build/debug/stm32h7xx_hal_rcc.o build/debug/stm32h7xx_hal_pwr_ex.o @@ -4308,7 +3943,6 @@ HAL_LTDC_ProgramLineEvent build/debug/stm32h7xx_hal_ltdc HAL_LTDC_Reload build/debug/stm32h7xx_hal_ltdc.o HAL_LTDC_ReloadEventCallback build/debug/stm32h7xx_hal_ltdc.o HAL_LTDC_SetAddress build/debug/stm32h7xx_hal_ltdc.o - build/debug/main.o HAL_LTDC_SetAddress_NoReload build/debug/stm32h7xx_hal_ltdc.o HAL_LTDC_SetAlpha build/debug/stm32h7xx_hal_ltdc.o HAL_LTDC_SetAlpha_NoReload build/debug/stm32h7xx_hal_ltdc.o @@ -4504,13 +4138,11 @@ HAL_RCCEx_GetPLL3ClockFreq build/debug/stm32h7xx_hal_rcc_ build/debug/stm32h7xx_hal_uart.o HAL_RCCEx_GetPeriphCLKConfig build/debug/stm32h7xx_hal_rcc_ex.o HAL_RCCEx_GetPeriphCLKFreq build/debug/stm32h7xx_hal_rcc_ex.o - build/debug/stm32h7xx_hal_sd.o HAL_RCCEx_KerWakeUpStopCLKConfig build/debug/stm32h7xx_hal_rcc_ex.o HAL_RCCEx_LSECSS_Callback build/debug/stm32h7xx_hal_rcc_ex.o HAL_RCCEx_LSECSS_IRQHandler build/debug/stm32h7xx_hal_rcc_ex.o HAL_RCCEx_PeriphCLKConfig build/debug/stm32h7xx_hal_rcc_ex.o build/debug/stm32h7xx_hal_msp.o - build/debug/main.o HAL_RCCEx_WakeUpStopCLKConfig build/debug/stm32h7xx_hal_rcc_ex.o HAL_RCC_CSSCallback build/debug/stm32h7xx_hal_rcc.o HAL_RCC_ClockConfig build/debug/stm32h7xx_hal_rcc.o @@ -4537,14 +4169,6 @@ HAL_RCC_OscConfig build/debug/stm32h7xx_hal_rcc. build/debug/main.o HAL_RS485Ex_Init build/debug/stm32h7xx_hal_uart_ex.o HAL_ResumeTick build/debug/stm32h7xx_hal.o -HAL_SDEx_ChangeDMABuffer build/debug/stm32h7xx_hal_sd_ex.o -HAL_SDEx_ConfigDMAMultiBuffer build/debug/stm32h7xx_hal_sd_ex.o -HAL_SDEx_ReadBlocksDMAMultiBuffer build/debug/stm32h7xx_hal_sd_ex.o -HAL_SDEx_Read_DMADoubleBuf0CpltCallback build/debug/stm32h7xx_hal_sd.o -HAL_SDEx_Read_DMADoubleBuf1CpltCallback build/debug/stm32h7xx_hal_sd.o -HAL_SDEx_WriteBlocksDMAMultiBuffer build/debug/stm32h7xx_hal_sd_ex.o -HAL_SDEx_Write_DMADoubleBuf0CpltCallback build/debug/stm32h7xx_hal_sd.o -HAL_SDEx_Write_DMADoubleBuf1CpltCallback build/debug/stm32h7xx_hal_sd.o HAL_SDRAM_DMA_XferCpltCallback build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_DMA_XferErrorCallback build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_DeInit build/debug/stm32h7xx_hal_sdram.o @@ -4557,12 +4181,14 @@ HAL_SDRAM_Init build/debug/stm32h7xx_hal_sdra HAL_SDRAM_MspDeInit build/debug/stm32h7xx_hal_msp.o HAL_SDRAM_MspInit build/debug/stm32h7xx_hal_msp.o HAL_SDRAM_ProgramRefreshRate build/debug/stm32h7xx_hal_sdram.o + build/debug/main.o HAL_SDRAM_Read_16b build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_Read_32b build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_Read_8b build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_Read_DMA build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_RefreshErrorCallback build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_SendCommand build/debug/stm32h7xx_hal_sdram.o + build/debug/main.o HAL_SDRAM_SetAutoRefreshNumber build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_WriteProtection_Disable build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_WriteProtection_Enable build/debug/stm32h7xx_hal_sdram.o @@ -4570,35 +4196,6 @@ HAL_SDRAM_Write_16b build/debug/stm32h7xx_hal_sdra HAL_SDRAM_Write_32b build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_Write_8b build/debug/stm32h7xx_hal_sdram.o HAL_SDRAM_Write_DMA build/debug/stm32h7xx_hal_sdram.o -HAL_SD_Abort build/debug/stm32h7xx_hal_sd.o -HAL_SD_AbortCallback build/debug/stm32h7xx_hal_sd.o -HAL_SD_Abort_IT build/debug/stm32h7xx_hal_sd.o -HAL_SD_ConfigSpeedBusOperation build/debug/stm32h7xx_hal_sd.o -HAL_SD_ConfigWideBusOperation build/debug/stm32h7xx_hal_sd.o -HAL_SD_DeInit build/debug/stm32h7xx_hal_sd.o -HAL_SD_Erase build/debug/stm32h7xx_hal_sd.o -HAL_SD_ErrorCallback build/debug/stm32h7xx_hal_sd.o -HAL_SD_GetCardCID build/debug/stm32h7xx_hal_sd.o -HAL_SD_GetCardCSD build/debug/stm32h7xx_hal_sd.o -HAL_SD_GetCardInfo build/debug/stm32h7xx_hal_sd.o -HAL_SD_GetCardState build/debug/stm32h7xx_hal_sd.o -HAL_SD_GetCardStatus build/debug/stm32h7xx_hal_sd.o -HAL_SD_GetError build/debug/stm32h7xx_hal_sd.o -HAL_SD_GetState build/debug/stm32h7xx_hal_sd.o -HAL_SD_IRQHandler build/debug/stm32h7xx_hal_sd.o -HAL_SD_Init build/debug/stm32h7xx_hal_sd.o - build/debug/main.o -HAL_SD_InitCard build/debug/stm32h7xx_hal_sd.o -HAL_SD_MspDeInit build/debug/stm32h7xx_hal_msp.o -HAL_SD_MspInit build/debug/stm32h7xx_hal_msp.o -HAL_SD_ReadBlocks build/debug/stm32h7xx_hal_sd.o -HAL_SD_ReadBlocks_DMA build/debug/stm32h7xx_hal_sd.o -HAL_SD_ReadBlocks_IT build/debug/stm32h7xx_hal_sd.o -HAL_SD_RxCpltCallback build/debug/stm32h7xx_hal_sd.o -HAL_SD_TxCpltCallback build/debug/stm32h7xx_hal_sd.o -HAL_SD_WriteBlocks build/debug/stm32h7xx_hal_sd.o -HAL_SD_WriteBlocks_DMA build/debug/stm32h7xx_hal_sd.o -HAL_SD_WriteBlocks_IT build/debug/stm32h7xx_hal_sd.o HAL_SYSCFG_AnalogSwitchConfig build/debug/stm32h7xx_hal.o HAL_SYSCFG_CompensationCodeConfig build/debug/stm32h7xx_hal.o HAL_SYSCFG_CompensationCodeSelect build/debug/stm32h7xx_hal.o @@ -4706,7 +4303,6 @@ OTG_HS_IRQHandler build/debug/startup_stm32h7a3x OTG_HS_WKUP_IRQHandler build/debug/startup_stm32h7a3xx.o PVD_PVM_IRQHandler build/debug/startup_stm32h7a3xx.o PendSV_Handler build/debug/stm32h7xx_it.o -PeriphCommonClock_Config build/debug/main.o RCC_IRQHandler build/debug/startup_stm32h7a3xx.o RNG_IRQHandler build/debug/startup_stm32h7a3xx.o RTC_Alarm_IRQHandler build/debug/startup_stm32h7a3xx.o @@ -4717,93 +4313,6 @@ SAI1_IRQHandler build/debug/startup_stm32h7a3x SAI2_IRQHandler build/debug/startup_stm32h7a3xx.o SDMMC1_IRQHandler build/debug/startup_stm32h7a3xx.o SDMMC2_IRQHandler build/debug/startup_stm32h7a3xx.o -SDMMC_CmdAppCommand build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdAppOperCommand build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdBlockCount build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdBlockLength build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdBusWidth build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdErase build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdEraseEndAdd build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdEraseStartAdd build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdGoIdleState build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdOpCondition build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdOperCond build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdReadMultiBlock build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd_ex.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdReadSingleBlock build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSDEraseEndAdd build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSDEraseStartAdd build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSelDesel build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSendCID build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSendCSD build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSendEXTCSD build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdSendOperationcondition build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdSendSCR build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSendStatus build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSetRelAdd build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSetRelAddMmc build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdSleepMmc build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdStatusRegister build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdStopTransfer build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdSwitch build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdVoltageSwitch build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_CmdWriteMultiBlock build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd_ex.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_CmdWriteSingleBlock build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_ConfigData build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd_ex.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_GetCmdResp1 build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetCmdResp2 build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetCmdResp3 build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetCmdResp4 build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetCmdResp5 build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetCmdResp6 build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetCmdResp7 build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetCommandResponse build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetDataCounter build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetFIFOCount build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_GetPowerState build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_GetResponse build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_Init build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_PowerState_Cycle build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_PowerState_OFF build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_PowerState_ON build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_ReadFIFO build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o -SDMMC_SDIO_CmdReadWriteDirect build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_SDIO_CmdReadWriteExtended build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_SendCommand build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_SetSDMMCReadWaitMode build/debug/stm32h7xx_ll_sdmmc.o -SDMMC_WriteFIFO build/debug/stm32h7xx_ll_sdmmc.o - build/debug/stm32h7xx_hal_sd.o SPDIF_RX_IRQHandler build/debug/startup_stm32h7a3xx.o SPI1_IRQHandler build/debug/startup_stm32h7a3xx.o SPI2_IRQHandler build/debug/startup_stm32h7a3xx.o @@ -4816,7 +4325,6 @@ SWPMI1_IRQHandler build/debug/startup_stm32h7a3x SysTick_Handler build/debug/stm32h7xx_it.o SystemClock_Config build/debug/main.o SystemCoreClock build/debug/system_stm32h7xx.o - build/debug/stm32h7xx_ll_sdmmc.o build/debug/stm32h7xx_hal_rcc_ex.o build/debug/stm32h7xx_hal_rcc.o build/debug/stm32h7xx_hal_mdma.o @@ -5141,7 +4649,6 @@ errno /usr/lib/gcc/arm-none-eabi/14. exit /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-exit.o) /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/crt0.o fflush /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-fflush.o) -framebuffer build/debug/main.o g_pfnVectors build/debug/startup_stm32h7a3xx.o hardware_init_hook /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/crt0.o hcrc build/debug/main.o @@ -5151,7 +4658,6 @@ hi2c4 build/debug/main.o hltdc build/debug/main.o build/debug/stm32h7xx_it.o hpcd_USB_OTG_HS build/debug/main.o -hsd2 build/debug/main.o hsdram1 build/debug/main.o build/debug/stm32h7xx_it.o huart10 build/debug/main.o @@ -5165,7 +4671,6 @@ memcpy /usr/lib/gcc/arm-none-eabi/14. build/debug/stm32h7xx_hal_fdcan.o memset /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-memset.o) /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/libc_nano.a(libc_a-findfp.o) - build/debug/stm32h7xx_hal_sd.o build/debug/stm32h7xx_hal_msp.o build/debug/main.o /usr/lib/gcc/arm-none-eabi/14.1.0/../../../../arm-none-eabi/lib/thumb/v7e-m+dp/hard/crt0.o