From 75133af2e7c092106939ed1401428a1606bb326d Mon Sep 17 00:00:00 2001 From: slhuan <953172510@qq.com> Date: Wed, 31 Aug 2022 15:14:16 +0800 Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=AD=A3stm32/stm32f103-100ask-mini?= =?UTF-8?q?=E5=92=8Cpro=E7=9A=84=E9=BB=98=E8=AE=A4=E4=B8=8B=E8=BD=BD?= =?UTF-8?q?=E5=99=A8=E4=B8=BAst-link=EF=BC=8C=E6=B7=BB=E5=8A=A0=E5=9F=BA?= =?UTF-8?q?=E4=BA=8Emm32f3270=E7=B3=BB=E5=88=97=E7=94=B1=E7=99=BE=E9=97=AE?= =?UTF-8?q?=E7=BD=91=E8=87=AA=E4=B8=BB=E8=AE=BE=E8=AE=A1=E7=9A=84=E7=81=AB?= =?UTF-8?q?=E9=BE=99=E6=9E=9C=E5=BC=80=E5=8F=91=E6=9D=BF=E7=9A=84bsp?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/action.yml | 1 + bsp/mm32/README.md | 10 + bsp/mm32/libraries/HAL_Drivers/Kconfig | 25 + bsp/mm32/libraries/HAL_Drivers/SConscript | 24 + .../config/mm32f3277g8p/dma_config.h | 206 + .../config/mm32f3277g8p/spi_config.h | 124 + .../config/mm32f3277g8p/uart_config.h | 110 + bsp/mm32/libraries/HAL_Drivers/drv_common.c | 167 + bsp/mm32/libraries/HAL_Drivers/drv_common.h | 55 + bsp/mm32/libraries/HAL_Drivers/drv_config.h | 29 + bsp/mm32/libraries/HAL_Drivers/drv_dma.h | 33 + bsp/mm32/libraries/HAL_Drivers/drv_gpio.c | 516 + bsp/mm32/libraries/HAL_Drivers/drv_gpio.h | 37 + bsp/mm32/libraries/HAL_Drivers/drv_spi.c | 833 ++ bsp/mm32/libraries/HAL_Drivers/drv_spi.h | 67 + bsp/mm32/libraries/HAL_Drivers/drv_uart.c | 432 + bsp/mm32/libraries/HAL_Drivers/drv_uart.h | 51 + bsp/mm32/libraries/Kconfig | 7 + .../MM32F3277/Include/hal_device_registers.h | 18 + .../MM32/MM32F3277/Include/mm32f3277g.h | 9587 +++++++++++++++++ .../MM32F3277/Include/mm32f3277g_features.h | 1837 ++++ .../MM32F3277/Include/system_mm32f3277g.h | 14 + .../Templates/arm/linker/mm32f3277g_flash.sct | 16 + .../Source/Templates/arm/startup_mm32f3270.s | 375 + .../Templates/gcc/linker/mm32f3277g_flash.ld | 208 + .../Source/Templates/gcc/startup_mm32f3270.s | 399 + .../Templates/iar/linker/mm32f3273g.icf | 30 + .../Source/Templates/iar/startup_mm32f3270.s | 306 + .../Source/Templates/system_mm32f3277g.c | 16 + .../CMSIS/Include/arm_common_tables.h | 378 + .../CMSIS/Include/arm_const_structs.h | 66 + .../MM32F3270_HAL/CMSIS/Include/arm_math.h | 7361 +++++++++++++ .../MM32F3270_HAL/CMSIS/Include/cmsis_armcc.h | 894 ++ .../CMSIS/Include/cmsis_armclang.h | 1444 +++ .../CMSIS/Include/cmsis_armclang_ltm.h | 1891 ++++ .../CMSIS/Include/cmsis_compiler.h | 283 + .../MM32F3270_HAL/CMSIS/Include/cmsis_gcc.h | 2168 ++++ .../CMSIS/Include/cmsis_iccarm.h | 964 ++ .../CMSIS/Include/cmsis_version.h | 39 + .../CMSIS/Include/core_armv81mml.h | 2968 +++++ .../CMSIS/Include/core_armv8mbl.h | 1921 ++++ .../CMSIS/Include/core_armv8mml.h | 2835 +++++ .../MM32F3270_HAL/CMSIS/Include/core_cm0.h | 952 ++ .../CMSIS/Include/core_cm0plus.h | 1085 ++ .../MM32F3270_HAL/CMSIS/Include/core_cm1.h | 979 ++ .../MM32F3270_HAL/CMSIS/Include/core_cm23.h | 1996 ++++ .../MM32F3270_HAL/CMSIS/Include/core_cm3.h | 1937 ++++ .../MM32F3270_HAL/CMSIS/Include/core_cm33.h | 2910 +++++ .../MM32F3270_HAL/CMSIS/Include/core_cm35p.h | 2910 +++++ .../MM32F3270_HAL/CMSIS/Include/core_cm4.h | 2124 ++++ .../MM32F3270_HAL/CMSIS/Include/core_cm7.h | 2725 +++++ .../MM32F3270_HAL/CMSIS/Include/core_dsp.h | 74 + .../MM32F3270_HAL/CMSIS/Include/core_sc000.h | 1025 ++ .../MM32F3270_HAL/CMSIS/Include/core_sc300.h | 1912 ++++ .../MM32F3270_HAL/CMSIS/Include/mpu_armv7.h | 272 + .../MM32F3270_HAL/CMSIS/Include/mpu_armv8.h | 346 + .../MM32F3270_HAL/CMSIS/Include/tz_context.h | 70 + .../MM32F3270_HAL_Driver/Inc/hal_adc.h | 462 + .../MM32F3270_HAL_Driver/Inc/hal_common.h | 17 + .../MM32F3270_HAL_Driver/Inc/hal_comp.h | 261 + .../MM32F3270_HAL_Driver/Inc/hal_dac.h | 364 + .../MM32F3270_HAL_Driver/Inc/hal_dma.h | 153 + .../Inc/hal_dma_request.h | 187 + .../MM32F3270_HAL_Driver/Inc/hal_exti.h | 128 + .../MM32F3270_HAL_Driver/Inc/hal_fsmc.h | 215 + .../MM32F3270_HAL_Driver/Inc/hal_gpio.h | 218 + .../MM32F3270_HAL_Driver/Inc/hal_i2c.h | 247 + .../MM32F3270_HAL_Driver/Inc/hal_iwdg.h | 133 + .../MM32F3270_HAL_Driver/Inc/hal_rcc.h | 219 + .../MM32F3270_HAL_Driver/Inc/hal_rtc.h | 246 + .../MM32F3270_HAL_Driver/Inc/hal_sdio.h | 287 + .../MM32F3270_HAL_Driver/Inc/hal_spi.h | 239 + .../MM32F3270_HAL_Driver/Inc/hal_syscfg.h | 277 + .../MM32F3270_HAL_Driver/Inc/hal_tim_16b.h | 637 ++ .../MM32F3270_HAL_Driver/Inc/hal_tim_32b.h | 635 ++ .../MM32F3270_HAL_Driver/Inc/hal_tim_adv.h | 750 ++ .../MM32F3270_HAL_Driver/Inc/hal_tim_basic.h | 168 + .../MM32F3270_HAL_Driver/Inc/hal_uart.h | 228 + .../MM32F3270_HAL_Driver/Inc/hal_usb.h | 399 + .../MM32F3270_HAL_Driver/Inc/hal_usb_bdt.h | 78 + .../MM32F3270_HAL_Driver/Inc/hal_wwdg.h | 128 + .../MM32F3270_HAL_Driver/Src/hal_adc.c | 313 + .../MM32F3270_HAL_Driver/Src/hal_comp.c | 121 + .../MM32F3270_HAL_Driver/Src/hal_dac.c | 326 + .../MM32F3270_HAL_Driver/Src/hal_dma.c | 86 + .../MM32F3270_HAL_Driver/Src/hal_exti.c | 74 + .../MM32F3270_HAL_Driver/Src/hal_fsmc.c | 115 + .../MM32F3270_HAL_Driver/Src/hal_gpio.c | 149 + .../MM32F3270_HAL_Driver/Src/hal_i2c.c | 357 + .../MM32F3270_HAL_Driver/Src/hal_iwdg.c | 59 + .../MM32F3270_HAL_Driver/Src/hal_rcc.c | 72 + .../MM32F3270_HAL_Driver/Src/hal_rtc.c | 372 + .../MM32F3270_HAL_Driver/Src/hal_sdio.c | 319 + .../MM32F3270_HAL_Driver/Src/hal_spi.c | 177 + .../MM32F3270_HAL_Driver/Src/hal_syscfg.c | 136 + .../MM32F3270_HAL_Driver/Src/hal_tim_16b.c | 302 + .../MM32F3270_HAL_Driver/Src/hal_tim_32b.c | 302 + .../MM32F3270_HAL_Driver/Src/hal_tim_adv.c | 418 + .../MM32F3270_HAL_Driver/Src/hal_tim_basic.c | 84 + .../MM32F3270_HAL_Driver/Src/hal_uart.c | 130 + .../MM32F3270_HAL_Driver/Src/hal_usb.c | 313 + .../MM32F3270_HAL_Driver/Src/hal_wwdg.c | 50 + bsp/mm32/libraries/MM32F3270_HAL/SConscript | 67 + bsp/mm32/mm32f3270-100ask-pitaya/Kconfig | 22 + bsp/mm32/mm32f3270-100ask-pitaya/README.md | 108 + bsp/mm32/mm32f3270-100ask-pitaya/SConscript | 15 + bsp/mm32/mm32f3270-100ask-pitaya/SConstruct | 60 + .../applications/SConscript | 15 + .../applications/main.c | 29 + .../mm32f3270-100ask-pitaya/board/Kconfig | 60 + .../mm32f3270-100ask-pitaya/board/SConscript | 33 + .../mm32f3270-100ask-pitaya/board/board.c | 176 + .../mm32f3270-100ask-pitaya/board/board.h | 71 + .../board/linker_scripts/link.icf | 30 + .../board/linker_scripts/link.ld | 208 + .../board/linker_scripts/link.sct | 16 + .../board/mm32f3277g8p_msp.c | 75 + .../board/ports/user_key.c | 42 + .../mm32f3270-100ask-pitaya/figures/board.png | Bin 0 -> 711438 bytes bsp/mm32/mm32f3270-100ask-pitaya/project.ewp | 2317 ++++ bsp/mm32/mm32f3270-100ask-pitaya/project.eww | 10 + .../mm32f3270-100ask-pitaya/project.uvoptx | 185 + .../mm32f3270-100ask-pitaya/project.uvprojx | 836 ++ bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.h | 211 + bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.py | 184 + bsp/mm32/mm32f3270-100ask-pitaya/template.ewp | 2074 ++++ bsp/mm32/mm32f3270-100ask-pitaya/template.eww | 7 + .../mm32f3270-100ask-pitaya/template.uvoptx | 185 + .../mm32f3270-100ask-pitaya/template.uvprojx | 405 + bsp/mm32/tools/sdk_dist.py | 22 + bsp/mm32/tools/upgrade.py | 145 + bsp/stm32/stm32f103-100ask-mini/README.md | 25 +- bsp/stm32/stm32f103-100ask-pro/README.md | 2 +- 133 files changed, 78635 insertions(+), 13 deletions(-) create mode 100644 bsp/mm32/README.md create mode 100644 bsp/mm32/libraries/HAL_Drivers/Kconfig create mode 100644 bsp/mm32/libraries/HAL_Drivers/SConscript create mode 100644 bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/dma_config.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/spi_config.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/uart_config.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_common.c create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_common.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_config.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_dma.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_gpio.c create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_gpio.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_spi.c create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_spi.h create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_uart.c create mode 100644 bsp/mm32/libraries/HAL_Drivers/drv_uart.h create mode 100644 bsp/mm32/libraries/Kconfig create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/hal_device_registers.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g_features.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/system_mm32f3277g.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/linker/mm32f3277g_flash.sct create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/startup_mm32f3270.s create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/linker/mm32f3277g_flash.ld create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/startup_mm32f3270.s create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/linker/mm32f3273g.icf create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/startup_mm32f3270.s create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/system_mm32f3277g.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_common_tables.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_const_structs.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_math.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armcc.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang_ltm.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_compiler.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_gcc.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_iccarm.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_version.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv81mml.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mbl.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mml.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0plus.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm1.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm23.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm3.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm33.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm35p.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm4.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm7.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_dsp.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc000.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc300.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv7.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv8.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/tz_context.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_adc.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_common.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_comp.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dac.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma_request.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_exti.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_fsmc.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_gpio.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_i2c.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_iwdg.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_rcc.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_rtc.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_sdio.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_spi.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_syscfg.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_tim_16b.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_tim_32b.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_tim_adv.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_tim_basic.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_uart.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_usb.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_usb_bdt.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_wwdg.h create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_adc.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_comp.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dac.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dma.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_exti.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_fsmc.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_gpio.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_i2c.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_iwdg.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rcc.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rtc.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_sdio.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_spi.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_syscfg.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_16b.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_32b.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_adv.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_basic.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_uart.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_usb.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_wwdg.c create mode 100644 bsp/mm32/libraries/MM32F3270_HAL/SConscript create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/Kconfig create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/README.md create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/SConscript create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/SConstruct create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/applications/SConscript create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/applications/main.c create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/Kconfig create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/SConscript create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/board.c create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/board.h create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.icf create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.ld create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.sct create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/mm32f3277g8p_msp.c create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/board/ports/user_key.c create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/figures/board.png create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/project.ewp create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/project.eww create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/project.uvoptx create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/project.uvprojx create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.h create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.py create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/template.ewp create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/template.eww create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/template.uvoptx create mode 100644 bsp/mm32/mm32f3270-100ask-pitaya/template.uvprojx create mode 100644 bsp/mm32/tools/sdk_dist.py create mode 100644 bsp/mm32/tools/upgrade.py diff --git a/.github/workflows/action.yml b/.github/workflows/action.yml index fddb4026a6..96230480a4 100644 --- a/.github/workflows/action.yml +++ b/.github/workflows/action.yml @@ -86,6 +86,7 @@ jobs: - {RTT_BSP: "fujitsu/mb9x/mb9bf618s", RTT_TOOL_CHAIN: "sourcery-arm"} - {RTT_BSP: "fujitsu/mb9x/mb9bf568r", RTT_TOOL_CHAIN: "sourcery-arm"} - {RTT_BSP: "mini2440", RTT_TOOL_CHAIN: "sourcery-arm"} + - {RTT_BSP: "mm32/mm32f3270-100ask-pitaya", RTT_TOOL_CHAIN: "sourcery-arm"} - {RTT_BSP: "nrf5x/nrf51822", RTT_TOOL_CHAIN: "sourcery-arm"} - {RTT_BSP: "nrf5x/nrf52832", RTT_TOOL_CHAIN: "sourcery-arm"} - {RTT_BSP: "nrf5x/nrf52833", RTT_TOOL_CHAIN: "sourcery-arm"} diff --git a/bsp/mm32/README.md b/bsp/mm32/README.md new file mode 100644 index 0000000000..a62bd4fff7 --- /dev/null +++ b/bsp/mm32/README.md @@ -0,0 +1,10 @@ +# MM32 BSP 说明 + +MM32 系列 BSP 目前支持情况如下表所示： + +| **BSP 文件夹名称** | **开发板名称** | +|:------------------------- |:-------------------------- | +| **F3270 系列** | | +| [mm32f3270-100ask-pitaya](mm32f3270-100ask-pitaya) | 百问网MM32F3273G8P火龙果开发板 | + +可以通过阅读相应 BSP 下的 README 来快速上手。 \ No newline at end of file diff --git a/bsp/mm32/libraries/HAL_Drivers/Kconfig b/bsp/mm32/libraries/HAL_Drivers/Kconfig new file mode 100644 index 0000000000..b47400eab1 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/Kconfig @@ -0,0 +1,25 @@ +if BSP_USING_USBD + config BSP_USBD_TYPE_FS + bool + # "USB Full Speed (FS) Core" + config BSP_USBD_TYPE_HS + bool + # "USB High Speed (HS) Core" + + config BSP_USBD_SPEED_HS + bool + # "USB High Speed (HS) Mode" + config BSP_USBD_SPEED_HSINFS + bool + # "USB High Speed (HS) Core in FS mode" + + config BSP_USBD_PHY_EMBEDDED + bool + # "Using Embedded phy interface" + config BSP_USBD_PHY_UTMI + bool + # "UTMI: USB 2.0 Transceiver Macrocell Interace" + config BSP_USBD_PHY_ULPI + bool + # "ULPI: UTMI+ Low Pin Interface" +endif diff --git a/bsp/mm32/libraries/HAL_Drivers/SConscript b/bsp/mm32/libraries/HAL_Drivers/SConscript new file mode 100644 index 0000000000..9a78e170ec --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/SConscript @@ -0,0 +1,24 @@ +Import('RTT_ROOT') +Import('rtconfig') +from building import * + +cwd = GetCurrentDir() + +# add the general drivers. +src = Split(""" +""") + +if GetDepend(['RT_USING_PIN']): + src += ['drv_gpio.c'] + +if GetDepend(['RT_USING_SERIAL']): + src += ['drv_uart.c'] + +src += ['drv_common.c'] + +path = [cwd] +path += [cwd + '/config'] + +group = DefineGroup('Drivers', src, depend = [''], CPPPATH = path) + +Return('group') diff --git a/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/dma_config.h b/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/dma_config.h new file mode 100644 index 0000000000..dd679c3d10 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/dma_config.h @@ -0,0 +1,206 @@ +/** + * @file dma_config.h + * @author 100ask development team + * @brief + * @version 0.1 + * @date 2022-06-16 + * + * @copyright Copyright (c) 2022 Chongqing 100ASK Technology Co., LTD + * + */ + +#ifndef __DMA_CONFIG_H__ +#define __DMA_CONFIG_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* DMA1 channel1 */ +#if defined(BSP_ADC1_USING_DMA) && !defined(ADC1_DMA_INSTANCE) +#define ADC1_DMA_INSTANCE DMA1 +#define ADC1_DMA_REQ DMA_REQ_DMA1_ADC1 +#define ADC1_DMA_IRQ DMA1_CH1_IRQn +#define ADC1_DMA_IRQHandler DMA1_Channel1_IRQHandler +#define ADC1_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#elif defined(BSP_UART6_RX_USING_DMA) && !defined(UART6_RX_DMA_INSTANCE) +#define UART6_DMA_INSTANCE DMA1 +#define UART6_RX_DMA_REQ DMA_REQ_DMA1_UART6_RX +#define UART6_RX_DMA_IRQ DMA1_CH1_IRQn +#define UART6_DMA_RX_IRQHandler DMA1_Channel1_IRQHandler +#define UART6_RX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#endif + +/* DMA1 channel2 */ +#if defined(BSP_ADC2_USING_DMA) && !defined(ADC2_DMA_INSTANCE) +#define ADC2_DMA_INSTANCE DMA1 +#define ADC2_DMA_REQ DMA_REQ_DMA1_ADC2 +#define ADC2_DMA_IRQ DMA1_CH2_IRQn +#define ADC2_DMA_IRQHandler DMA1_Channel2_IRQHandler +#define ADC2_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#elif defined(BSP_SPI1_RX_USING_DMA) && !defined(SPI1_RX_DMA_INSTANCE) +#define SPI1_RX_DMA_INSTANCE DMA1 +#define SPI1_RX_DMA_REQ DMA_REQ_DMA1_SPI1_RX +#define SPI1_RX_DMA_IRQ DMA1_CH2_IRQn +#define SPI1_DMA_RX_IRQHandler DMA1_Channel2_IRQHandler +#define SPI1_RX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#elif defined(BSP_UART3_TX_USING_DMA) && !defined(UART3_TX_DMA_INSTANCE) +#define UART3_TX_DMA_INSTANCE DMA1 +#define UART3_TX_DMA_REQ DMA_REQ_DMA1_UART3_TX +#define UART3_TX_DMA_IRQ DMA1_CH2_IRQn +#define UART3_DMA_TX_IRQHandler DMA1_Channel2_IRQHandler +#define UART3_TX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#endif + +/* DMA1 channel3 */ +#if defined(BSP_SPI1_TX_USING_DMA) && !defined(SPI1_TX_DMA_INSTANCE) +#define SPI1_TX_DMA_INSTANCE DMA1 +#define SPI1_TX_DMA_REQ DMA_REQ_DMA1_SPI1_TX +#define SPI1_TX_DMA_IRQ DMA1_CH3_IRQn +#define SPI1_DMA_TX_IRQHandler DMA1_Channel3_IRQHandler +#define SPI1_TX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#elif defined(BSP_UART3_RX_USING_DMA) && !defined(UART3_RX_DMA_INSTANCE) +#define UART3_RX_DMA_INSTANCE DMA1 +#define UART3_RX_DMA_REQ DMA_REQ_DMA1_UART3_RX +#define UART3_RX_DMA_IRQ DMA1_CH3_IRQn +#define UART3_DMA_RX_IRQHandler DMA1_Channel3_IRQHandler +#define UART3_RX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#endif + +/* DMA1 channel4 */ +#if defined(BSP_SPI2_RX_USING_DMA) && !defined(SPI2_RX_DMA_INSTANCE) +#define SPI2_RX_DMA_INSTANCE DMA1 +#define SPI2_RX_DMA_REQ DMA_REQ_DMA1_SPI2_RX +#define SPI2_RX_DMA_IRQ DMA1_CH4_IRQn +#define SPI2_DMA_RX_IRQHandler DMA1_Channel4_IRQHandler +#define SPI2_RX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#elif defined(BSP_UART1_TX_USING_DMA) && !defined(UART1_TX_DMA_INSTANCE) +#define UART1_TX_DMA_INSTANCE DMA1 +#define UART1_TX_DMA_REQ DMA_REQ_DMA1_UART1_TX +#define UART1_TX_DMA_IRQ DMA1_CH4_IRQn +#define UART1_DMA_TX_IRQHandler DMA1_Channel4_IRQHandler +#define UART1_TX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#endif + +/* DMA1 channel5 */ +#if defined(BSP_SPI2_TX_USING_DMA) && !defined(SPI2_TX_DMA_INSTANCE) +#define SPI2_TX_DMA_INSTANCE DMA1 +#define SPI2_TX_DMA_REQ DMA_REQ_DMA1_SPI2_TX +#define SPI2_TX_DMA_IRQ DMA1_CH5_IRQn +#define SPI2_DMA_TX_IRQHandler DMA1_Channel5_IRQHandler +#define SPI2_TX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#elif defined(BSP_UART1_RX_USING_DMA) && !defined(UART1_RX_DMA_INSTANCE) +#define UART1_RX_DMA_INSTANCE DMA1 +#define UART1_RX_DMA_REQ DMA_REQ_DMA1_UART1_RX +#define UART1_RX_DMA_IRQ DMA1_CH5_IRQn +#define UART1_DMA_RX_IRQHandler DMA1_Channel5_IRQHandler +#define UART1_RX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#endif + +/* DMA1 channel6 */ +#if defined(BSP_UART2_RX_USING_DMA) && !defined(UART2_RX_DMA_INSTANCE) +#define UART6_RX_DMA_INSTANCE DMA1 +#define UART6_RX_DMA_REQ DMA_REQ_DMA1_UART6_RX +#define UART6_RX_DMA_IRQ DMA1_CH6_IRQn +#define UART6_DMA_RX_IRQHandler DMA1_Channel6_IRQHandler +#define UART6_RX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#endif + +/* DMA1 channel7 */ +#if defined(BSP_UART2_TX_USING_DMA) && !defined(UART2_TX_DMA_INSTANCE) +#define UART2_TX_DMA_INSTANCE DMA1 +#define UART2_TX_DMA_REQ DMA_REQ_DMA1_UART2_TX +#define UART2_TX_DMA_IRQ DMA1_CH7_IRQn +#define UART2_DMA_TX_IRQHandler DMA1_Channel7_IRQHandler +#define UART2_TX_DMA_RCC RCC_AHB1_PERIPH_DMA1 +#endif + +/* DMA2 channel1 */ +#if defined(BSP_SPI3_RX_USING_DMA) && !defined(SPI3_RX_DMA_INSTANCE) +#define SPI3_RX_DMA_INSTANCE DMA2 +#define SPI3_RX_DMA_REQ DMA_REQ_DMA2_SPI3_RX +#define SPI3_RX_DMA_IRQ DMA2_CH1_IRQn +#define SPI3_DMA_RX_IRQHandler DMA2_Channel1_IRQHandler +#define SPI3_RX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#elif defined(BSP_UART5_RX_USING_DMA) && !defined(UART5_RX_DMA_INSTANCE) +#define UART5_RX_DMA_INSTANCE DMA2 +#define UART5_RX_DMA_REQ DMA_REQ_DMA2_UART5_RX +#define UART5_RX_DMA_IRQ DMA2_CH1_IRQn +#define UART5_DMA_RX_IRQHandler DMA2_Channel1_IRQHandler +#define UART5_RX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#elif defined(BSP_UART7_RX_USING_DMA) && !defined(UART7_RX_DMA_INSTANCE) +#define UART7_RX_DMA_INSTANCE DMA2 +#define UART7_RX_DMA_REQ DMA_REQ_DMA2_UART7_RX +#define UART7_RX_DMA_IRQ DMA2_CH1_IRQn +#define UART7_DMA_RX_IRQHandler DMA2_Channel1_IRQHandler +#define UART7_RX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#endif + +/* DMA2 channel2 */ +#if defined(BSP_SPI3_TX_USING_DMA) && !defined(SPI3_TX_DMA_INSTANCE) +#define SPI3_TX_DMA_INSTANCE DMA2 +#define SPI3_TX_DMA_REQ DMA_REQ_DMA2_SPI3_TX +#define SPI3_TX_DMA_IRQ DMA2_CH2_IRQn +#define SPI3_DMA_TX_IRQHandler DMA2_Channel2_IRQHandler +#define SPI3_TX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#elif defined(BSP_UART5_TX_USING_DMA) && !defined(UART5_TX_DMA_INSTANCE) +#define UART5_TX_DMA_INSTANCE DMA2 +#define UART5_TX_DMA_REQ DMA_REQ_DMA2_UART5_TX +#define UART5_TX_DMA_IRQ DMA2_CH2_IRQn +#define UART5_DMA_TX_IRQHandler DMA2_Channel2_IRQHandler +#define UART5_TX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#elif defined(BSP_UART7_TX_USING_DMA) && !defined(UART7_TX_DMA_INSTANCE) +#define UART7_TX_DMA_INSTANCE DMA2 +#define UART7_TX_DMA_REQ DMA_REQ_DMA2_UART7_TX +#define UART7_TX_DMA_IRQ DMA2_CH2_IRQn +#define UART7_DMA_TX_IRQHandler DMA2_Channel2_IRQHandler +#define UART7_TX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#endif + +/* DMA2 channel3 */ +#if defined(BSP_UART4_RX_USING_DMA) && !defined(UART4_RX_DMA_INSTANCE) +#define UART4_RX_DMA_INSTANCE DMA2 +#define UART4_RX_DMA_REQ DMA_REQ_DMA2_UART4_RX +#define UART4_RX_DMA_IRQ DMA2_CH3_IRQn +#define UART4_DMA_RX_IRQHandler DMA2_Channel3_IRQHandler +#define UART4_RX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#elif defined(BSP_UART8_RX_USING_DMA) && !defined(UART8_RX_DMA_INSTANCE) +#define UART8_RX_DMA_INSTANCE DMA2 +#define UART8_RX_DMA_REQ DMA_REQ_DMA2_UART8_RX +#define UART8_RX_DMA_IRQ DMA2_CH3_IRQn +#define UART8_DMA_RX_IRQHandler DMA2_Channel3_IRQHandler +#define UART8_RX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#endif + +/* DMA2 channel4 */ +#if defined(BSP_UART6_TX_USING_DMA) && !defined(UART6_TX_DMA_INSTANCE) +#define UART6_TX_DMA_INSTANCE DMA2 +#define UART6_TX_DMA_REQ DMA_REQ_DMA2_UART6_TX +#define UART6_TX_DMA_IRQ DMA2_CH4_IRQn +#define UART6_DMA_TX_IRQHandler DMA2_Channel4_IRQHandler +#define UART6_TX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#endif + +/* DMA2 channel5 */ +#if defined(BSP_UART4_TX_USING_DMA) && !defined(UART4_TX_DMA_INSTANCE) +#define UART4_TX_DMA_INSTANCE DMA2 +#define UART4_TX_DMA_REQ DMA_REQ_DMA2_UART4_TX +#define UART4_TX_DMA_IRQ DMA2_CH5_IRQn +#define UART4_DMA_TX_IRQHandler DMA2_Channel5_IRQHandler +#define UART4_TX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#elif defined(BSP_UART8_TX_USING_DMA) && !defined(UART8_TX_DMA_INSTANCE) +#define UART8_TX_DMA_INSTANCE DMA2 +#define UART8_TX_DMA_REQ DMA_REQ_DMA2_UART8_TX +#define UART8_TX_DMA_IRQ DMA2_CH5_IRQn +#define UART8_DMA_TX_IRQHandler DMA2_Channel5_IRQHandler +#define UART8_TX_DMA_RCC RCC_AHB1_PERIPH_DMA2 +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __DMA_CONFIG_H__ */ + diff --git a/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/spi_config.h b/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/spi_config.h new file mode 100644 index 0000000000..09331726ac --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/spi_config.h @@ -0,0 +1,124 @@ +/** + * @file spi_config.h + * @author 100ask development team + * @brief + * @version 0.1 + * @date 2022-06-16 + * + * @copyright Copyright (c) 2022 Chongqing 100ASK Technology Co., LTD + * + */ + + +#ifndef __SPI_CONFIG_H__ +#define __SPI_CONFIG_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef BSP_USING_SPI1 +#ifndef SPI1_BUS_CONFIG +#define SPI1_BUS_CONFIG \ + { \ + .Instance = SPI1, \ + .bus_name = "spi1", \ + } +#endif /* SPI1_BUS_CONFIG */ +#endif /* BSP_USING_SPI1 */ + +#ifdef BSP_SPI1_TX_USING_DMA +#ifndef SPI1_TX_DMA_CONFIG +#define SPI1_TX_DMA_CONFIG \ + { \ + .dma_port = SPI1_TX_DMA_PORT, \ + .dma_rcc = SPI1_TX_DMA_RCC, \ + .Instance = SPI1_TX_DMA_INSTANCE, \ + .dma_irq = SPI1_TX_DMA_IRQ, \ + } +#endif /* SPI1_TX_DMA_CONFIG */ +#endif /* BSP_SPI1_TX_USING_DMA */ + +#ifdef BSP_SPI1_RX_USING_DMA +#ifndef SPI1_RX_DMA_CONFIG +#define SPI1_RX_DMA_CONFIG \ + { \ + .dma_rcc = SPI1_RX_DMA_RCC, \ + .Instance = SPI1_RX_DMA_INSTANCE, \ + .dma_irq = SPI1_RX_DMA_IRQ, \ + } +#endif /* SPI1_RX_DMA_CONFIG */ +#endif /* BSP_SPI1_RX_USING_DMA */ + +#ifdef BSP_USING_SPI2 +#ifndef SPI2_BUS_CONFIG +#define SPI2_BUS_CONFIG \ + { \ + .Instance = SPI2, \ + .bus_name = "spi2", \ + } +#endif /* SPI2_BUS_CONFIG */ +#endif /* BSP_USING_SPI2 */ + +#ifdef BSP_SPI2_TX_USING_DMA +#ifndef SPI2_TX_DMA_CONFIG +#define SPI2_TX_DMA_CONFIG \ + { \ + .dma_rcc = SPI2_TX_DMA_RCC, \ + .Instance = SPI2_TX_DMA_INSTANCE, \ + .dma_irq = SPI2_TX_DMA_IRQ, \ + } +#endif /* SPI2_TX_DMA_CONFIG */ +#endif /* BSP_SPI2_TX_USING_DMA */ + +#ifdef BSP_SPI2_RX_USING_DMA +#ifndef SPI2_RX_DMA_CONFIG +#define SPI2_RX_DMA_CONFIG \ + { \ + .dma_rcc = SPI2_RX_DMA_RCC, \ + .Instance = SPI2_RX_DMA_INSTANCE, \ + .dma_irq = SPI2_RX_DMA_IRQ, \ + } +#endif /* SPI2_RX_DMA_CONFIG */ +#endif /* BSP_SPI2_RX_USING_DMA */ + +#ifdef BSP_USING_SPI3 +#ifndef SPI3_BUS_CONFIG +#define SPI3_BUS_CONFIG \ + { \ + .Instance = SPI3, \ + .bus_name = "spi3", \ + } +#endif /* SPI3_BUS_CONFIG */ +#endif /* BSP_USING_SPI3 */ + +#ifdef BSP_SPI3_TX_USING_DMA +#ifndef SPI3_TX_DMA_CONFIG +#define SPI3_TX_DMA_CONFIG \ + { \ + .dma_rcc = SPI3_TX_DMA_RCC, \ + .Instance = SPI3_TX_DMA_INSTANCE, \ + .dma_irq = SPI3_TX_DMA_IRQ, \ + } +#endif /* SPI3_TX_DMA_CONFIG */ +#endif /* BSP_SPI3_TX_USING_DMA */ + +#ifdef BSP_SPI3_RX_USING_DMA +#ifndef SPI3_RX_DMA_CONFIG +#define SPI3_RX_DMA_CONFIG \ + { \ + .dma_rcc = SPI3_RX_DMA_RCC, \ + .Instance = SPI3_RX_DMA_INSTANCE, \ + .dma_irq = SPI3_RX_DMA_IRQ, \ + } +#endif /* SPI3_RX_DMA_CONFIG */ +#endif /* BSP_SPI3_RX_USING_DMA */ + +#ifdef __cplusplus +} +#endif + +#endif /*__SPI_CONFIG_H__ */ + diff --git a/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/uart_config.h b/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/uart_config.h new file mode 100644 index 0000000000..ddff2d7f4b --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/config/mm32f3277g8p/uart_config.h @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#ifndef __UART_CONFIG_H__ +#define __UART_CONFIG_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(BSP_USING_UART1) +#ifndef UART1_CONFIG +#define UART1_CONFIG \ + { \ + .name = "uart1", \ + .Instance = UART1, \ + .irq_type = UART1_IRQn, \ + } +#endif /* UART1_CONFIG */ +#endif /* BSP_USING_UART1 */ + +#if defined(BSP_USING_UART2) +#ifndef UART2_CONFIG +#define UART2_CONFIG \ + { \ + .name = "uart2", \ + .Instance = UART2, \ + .irq_type = UART2_IRQn, \ + } +#endif /* UART2_CONFIG */ +#endif /* BSP_USING_UART2 */ + +#if defined(BSP_USING_UART3) +#ifndef UART3_CONFIG +#define UART3_CONFIG \ + { \ + .name = "uart3", \ + .Instance = UART3, \ + .irq_type = UART3_IRQn, \ + } +#endif /* UART3_CONFIG */ +#endif /* BSP_USING_UART3 */ + +#if defined(BSP_USING_UART4) +#ifndef UART4_CONFIG +#define UART4_CONFIG \ + { \ + .name = "uart4", \ + .Instance = UART4, \ + .irq_type = UART4_IRQn, \ + } +#endif /* UART4_CONFIG */ +#endif /* BSP_USING_UART4 */ + +#if defined(BSP_USING_UART5) +#ifndef UART5_CONFIG +#define UART5_CONFIG \ + { \ + .name = "uart5", \ + .Instance = UART5, \ + .irq_type = UART5_IRQn, \ + } +#endif /* UART5_CONFIG */ +#endif /* BSP_USING_UART5 */ + +#if defined(BSP_USING_UART6) +#ifndef UART6_CONFIG +#define UART6_CONFIG \ + { \ + .name = "uart6", \ + .Instance = UART6, \ + .irq_type = UART6_IRQn, \ + } +#endif /* UART5_CONFIG */ +#endif /* BSP_USING_UART5 */ + +#if defined(BSP_USING_UART7) +#ifndef UART7_CONFIG +#define UART7_CONFIG \ + { \ + .name = "uart7", \ + .Instance = UART7, \ + .irq_type = UART7_IRQn, \ + } +#endif /* UART5_CONFIG */ +#endif /* BSP_USING_UART5 */ + +#if defined(BSP_USING_UART8) +#ifndef UART8_CONFIG +#define UART8_CONFIG \ + { \ + .name = "uart8", \ + .Instance = UART8, \ + .irq_type = UART8_IRQn, \ + } +#endif /* UART5_CONFIG */ +#endif /* BSP_USING_UART5 */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_common.c b/bsp/mm32/libraries/HAL_Drivers/drv_common.c new file mode 100644 index 0000000000..03a92f6179 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_common.c @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#include "drv_common.h" + +#define DBG_TAG "drv_common" +#define DBG_LVL DBG_INFO +#include + +#ifdef RT_USING_FINSH +#include +static void reboot(uint8_t argc, char **argv) +{ + rt_hw_cpu_reset(); +} +MSH_CMD_EXPORT(reboot, Reboot System); +#endif /* RT_USING_FINSH */ + +volatile uint32_t uwTick; +static uint32_t _systick_ms = 1; +void HAL_IncTick(void); + +/* SysTick configuration */ +void rt_hw_systick_init(void) +{ + uint32_t prioritygroup = 0x00U; + uint32_t SystemCoreClock = HAL_GetSysClockFreq(); + /* Configure the SysTick to have interrupt in 1ms time basis*/ + if(SysTick_Config(SystemCoreClock/1000) > 0) + { + return; + } + /* Configure the SysTick IRQ priority */ + prioritygroup = NVIC_GetPriorityGrouping(); + NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(prioritygroup, 15, 0)); + + _systick_ms = 1000u / RT_TICK_PER_SECOND; + if(_systick_ms == 0) + _systick_ms = 1; +} + +/** + * This is the timer interrupt service routine. + * + */ +void SysTick_Handler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + if(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk) + HAL_IncTick(); + + rt_tick_increase(); + + /* leave interrupt */ + rt_interrupt_leave(); +} + +void HAL_IncTick(void) +{ + uwTick += _systick_ms; +} + +/** + * @brief This function is executed in case of error occurrence. + * @param None + * @retval None + */ +void _Error_Handler(char *s, int num) +{ + /* USER CODE BEGIN Error_Handler */ + /* User can add his own implementation to report the HAL error return state */ + LOG_E("Error_Handler at file:%s num:%d", s, num); + while (1) + { + } + /* USER CODE END Error_Handler */ +} + +/** + * This function will delay for some us. + * + * @param us the delay time of us + */ +void rt_hw_us_delay(rt_uint32_t us) +{ + rt_uint32_t ticks; + rt_uint32_t told, tnow, tcnt = 0; + rt_uint32_t reload = SysTick->LOAD; + + ticks = us * reload / (1000000 / RT_TICK_PER_SECOND); + told = SysTick->VAL; + while (1) + { + tnow = SysTick->VAL; + if (tnow != told) + { + if (tnow < told) + { + tcnt += told - tnow; + } + else + { + tcnt += reload - tnow + told; + } + told = tnow; + if (tcnt >= ticks) + { + break; + } + } + } +} + +/** + * This function will initial STM32 board. + */ +RT_WEAK void rt_hw_board_init() +{ +#ifdef BSP_SCB_ENABLE_I_CACHE + /* Enable I-Cache---------------------------------------------------------*/ + SCB_EnableICache(); +#endif + +#ifdef BSP_SCB_ENABLE_D_CACHE + /* Enable D-Cache---------------------------------------------------------*/ + SCB_EnableDCache(); +#endif + + /* System clock initialization */ + SystemClock_Config(); + + rt_hw_systick_init(); + + /* Heap initialization */ +#if defined(RT_USING_HEAP) + rt_system_heap_init((void *)HEAP_BEGIN, (void *)HEAP_END); +#endif + + /* Pin driver initialization is open by default */ +#ifdef RT_USING_PIN + rt_hw_pin_init(); +#endif + + /* USART driver initialization is open by default */ +#ifdef RT_USING_SERIAL + rt_hw_uart_init(); +#endif + + /* Set the shell console output device */ +#if defined(RT_USING_CONSOLE) && defined(RT_USING_DEVICE) + rt_console_set_device(RT_CONSOLE_DEVICE_NAME); +#endif + + /* Board underlying hardware initialization */ +#ifdef RT_USING_COMPONENTS_INIT + rt_components_board_init(); +#endif +} + + diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_common.h b/bsp/mm32/libraries/HAL_Drivers/drv_common.h new file mode 100644 index 0000000000..f6648e9898 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_common.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#ifndef __DRV_COMMON_H__ +#define __DRV_COMMON_H__ + +#include +#include + +#include + +#include +#include +#include + +#ifdef RT_USING_PIN +#include +#include +#include +#endif + +#ifdef RT_USING_SERIAL +#include +#endif + +#ifdef RT_USING_SPI +#include +#endif + +#ifdef RT_USING_DEVICE +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void _Error_Handler(char *s, int num); + +#ifndef Error_Handler +#define Error_Handler() _Error_Handler(__FILE__, __LINE__) +#endif + +#define DMA_NOT_AVAILABLE ((DMA_INSTANCE_TYPE *)0xFFFFFFFFU) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_config.h b/bsp/mm32/libraries/HAL_Drivers/drv_config.h new file mode 100644 index 0000000000..20e230b5c8 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_config.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#ifndef __DRV_CONFIG_H__ +#define __DRV_CONFIG_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(SOC_SERIES_MM32F3277) +#include "mm32f3277g8p/dma_config.h" +#include "mm32f3277g8p/uart_config.h" +#include "mm32f3277g8p/spi_config.h" +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_dma.h b/bsp/mm32/libraries/HAL_Drivers/drv_dma.h new file mode 100644 index 0000000000..0fe741c2bf --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_dma.h @@ -0,0 +1,33 @@ +/** + * @file drv_dma.h + * @author 100ask development team + * @brief + * @version 0.1 + * @date 2022-06-16 + * + * @copyright Copyright (c) 2022 Chongqing 100ASK Technology Co., LTD + * + */ + +#ifndef __DRV_DMA_H_ +#define __DRV_DMA_H_ + +#include +#include "drv_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct dma_config { + DMA_Type *dma_port; + rt_uint32_t dma_req; + IRQn_Type dma_irq; + rt_uint32_t dma_rcc; +}; + +#ifdef __cplusplus +} +#endif + +#endif /*__DRV_DMA_H_ */ diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_gpio.c b/bsp/mm32/libraries/HAL_Drivers/drv_gpio.c new file mode 100644 index 0000000000..dd6df7174a --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_gpio.c @@ -0,0 +1,516 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#include "drv_gpio.h" + +#ifdef RT_USING_PIN + +#define PIN_NUM(port, no) (((((port) & 0xFu) << 4) | ((no) & 0xFu))) +#define PIN_PORT(pin) ((uint8_t)(((pin) >> 4) & 0xFu)) +#define PIN_NO(pin) ((uint8_t)((pin) & 0xFu)) + +#define PIN_STPORT(pin) ((GPIO_Type *)(GPIOA_BASE + (0x400u * PIN_PORT(pin)))) + +#define PIN_STPIN(pin) ((uint16_t)(1u << PIN_NO(pin))) + + +#if defined(GPIOF) +#define __MM32_PORT_MAX 6u +#elif defined(GPIOE) +#define __MM32_PORT_MAX 5u +#elif defined(GPIOD) +#define __MM32_PORT_MAX 4u +#elif defined(GPIOC) +#define __MM32_PORT_MAX 3u +#elif defined(GPIOB) +#define __MM32_PORT_MAX 2u +#elif defined(GPIOA) +#define __MM32_PORT_MAX 1u +#else +#define __MM32_PORT_MAX 0u +#error Unsupported MM32 GPIO peripheral. +#endif + +#define PIN_STPORT_MAX __MM32_PORT_MAX + +#define GET_EXTI_PORT(PORT) + +static const struct pin_irq_map pin_irq_map[] = +{ + {GPIO_PIN_0, EXTI0_IRQn, EXTI_LINE_0, SYSCFG_EXTILine_0}, + {GPIO_PIN_1, EXTI1_IRQn, EXTI_LINE_1, SYSCFG_EXTILine_1}, + {GPIO_PIN_2, EXTI2_IRQn, EXTI_LINE_2, SYSCFG_EXTILine_2}, + {GPIO_PIN_3, EXTI3_IRQn, EXTI_LINE_3, SYSCFG_EXTILine_3}, + {GPIO_PIN_4, EXTI4_IRQn, EXTI_LINE_4, SYSCFG_EXTILine_4}, + {GPIO_PIN_5, EXTI9_5_IRQn, EXTI_LINE_5,SYSCFG_EXTILine_5}, + {GPIO_PIN_6, EXTI9_5_IRQn, EXTI_LINE_6, SYSCFG_EXTILine_6}, + {GPIO_PIN_7, EXTI9_5_IRQn, EXTI_LINE_7, SYSCFG_EXTILine_7}, + {GPIO_PIN_8, EXTI9_5_IRQn, EXTI_LINE_8, SYSCFG_EXTILine_8}, + {GPIO_PIN_9, EXTI9_5_IRQn, EXTI_LINE_9, SYSCFG_EXTILine_9}, + {GPIO_PIN_10, EXTI15_10_IRQn, EXTI_LINE_10, SYSCFG_EXTILine_10}, + {GPIO_PIN_11, EXTI15_10_IRQn, EXTI_LINE_11, SYSCFG_EXTILine_11}, + {GPIO_PIN_12, EXTI15_10_IRQn, EXTI_LINE_12, SYSCFG_EXTILine_12}, + {GPIO_PIN_13, EXTI15_10_IRQn, EXTI_LINE_13, SYSCFG_EXTILine_13}, + {GPIO_PIN_14, EXTI15_10_IRQn, EXTI_LINE_14, SYSCFG_EXTILine_14}, + {GPIO_PIN_15, EXTI15_10_IRQn, EXTI_LINE_15, SYSCFG_EXTILine_15}, +}; + +static struct rt_pin_irq_hdr pin_irq_hdr_tab[] = +{ + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, + {-1, 0, RT_NULL, RT_NULL}, +}; +static uint32_t pin_irq_enable_mask = 0; + +#define ITEM_NUM(items) sizeof(items) / sizeof(items[0]) + +static rt_base_t mm32_pin_get(const char *name) +{ + rt_base_t pin = 0; + int hw_port_num, hw_pin_num = 0; + int i, name_len; + + name_len = rt_strlen(name); + + if ((name_len < 4) || (name_len >= 6)) + { + return -RT_EINVAL; + } + if ((name[0] != 'P') || (name[2] != '.')) + { + return -RT_EINVAL; + } + + if ((name[1] >= 'A') && (name[1] <= 'F')) + { + hw_port_num = (int)(name[1] - 'A'); + } + else + { + return -RT_EINVAL; + } + + for (i = 3; i < name_len; i++) + { + hw_pin_num *= 10; + hw_pin_num += name[i] - '0'; + } + + pin = PIN_NUM(hw_port_num, hw_pin_num); + + return pin; +} + +static void mm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value) +{ + GPIO_Type *gpio_port; + uint16_t gpio_pin; + + if (PIN_PORT(pin) < PIN_STPORT_MAX) + { + gpio_port = PIN_STPORT(pin); + gpio_pin = PIN_STPIN(pin); + + GPIO_WriteBit(gpio_port, gpio_pin, (rt_uint16_t)value); + } +} + +static int mm32_pin_read(rt_device_t dev, rt_base_t pin) +{ + GPIO_Type *gpio_port; + uint16_t gpio_pin; + int value = PIN_LOW; + + if (PIN_PORT(pin) < PIN_STPORT_MAX) + { + gpio_port = PIN_STPORT(pin); + gpio_pin = PIN_STPIN(pin); + value = GPIO_ReadInDataBit(gpio_port, gpio_pin); + } + + return value; +} + +static void mm32_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode) +{ + GPIO_Init_Type GPIO_InitStruct; + + if (PIN_PORT(pin) >= PIN_STPORT_MAX) + { + return; + } + + /* Configure GPIO_InitStructure */ + GPIO_InitStruct.Pins = PIN_STPIN(pin); + GPIO_InitStruct.PinMode = GPIO_PinMode_Out_PushPull; + GPIO_InitStruct.Speed = GPIO_Speed_50MHz; + + if (mode == PIN_MODE_OUTPUT) + { + /* output setting */ + GPIO_InitStruct.PinMode = GPIO_PinMode_Out_PushPull; + } + else if (mode == PIN_MODE_INPUT) + { + /* input setting: not pull. */ + GPIO_InitStruct.PinMode = GPIO_PinMode_In_Floating; + } + else if (mode == PIN_MODE_INPUT_PULLUP) + { + /* input setting: pull up. */ + GPIO_InitStruct.PinMode = GPIO_PinMode_In_PullUp; + } + else if (mode == PIN_MODE_INPUT_PULLDOWN) + { + /* input setting: pull down. */ + GPIO_InitStruct.PinMode = GPIO_PinMode_In_PullDown; + } + else if (mode == PIN_MODE_OUTPUT_OD) + { + /* output setting: od. */ + GPIO_InitStruct.PinMode = GPIO_PinMode_Out_OpenDrain; + } + + GPIO_Init(PIN_STPORT(pin), &GPIO_InitStruct); +} + +rt_inline rt_int32_t bit2bitno(rt_uint32_t bit) +{ + rt_uint8_t i; + for (i = 0; i < 32; i++) + { + if ((0x01 << i) == bit) + { + return i; + } + } + return -1; +} + +rt_inline const struct pin_irq_map *get_pin_irq_map(uint32_t pinbit) +{ + rt_int32_t mapindex = bit2bitno(pinbit); + if (mapindex < 0 || mapindex >= ITEM_NUM(pin_irq_map)) + { + return RT_NULL; + } + return &pin_irq_map[mapindex]; +}; + +static rt_err_t mm32_pin_attach_irq(struct rt_device *device, rt_int32_t pin, + rt_uint32_t mode, void (*hdr)(void *args), void *args) +{ + rt_base_t level; + rt_int32_t irqindex = -1; + + if (PIN_PORT(pin) >= PIN_STPORT_MAX) + { + return -RT_ENOSYS; + } + + irqindex = bit2bitno(PIN_STPIN(pin)); + if (irqindex < 0 || irqindex >= ITEM_NUM(pin_irq_map)) + { + return RT_ENOSYS; + } + + level = rt_hw_interrupt_disable(); + if (pin_irq_hdr_tab[irqindex].pin == pin && + pin_irq_hdr_tab[irqindex].hdr == hdr && + pin_irq_hdr_tab[irqindex].mode == mode && + pin_irq_hdr_tab[irqindex].args == args) + { + rt_hw_interrupt_enable(level); + return RT_EOK; + } + if (pin_irq_hdr_tab[irqindex].pin != -1) + { + rt_hw_interrupt_enable(level); + return RT_EBUSY; + } + pin_irq_hdr_tab[irqindex].pin = pin; + pin_irq_hdr_tab[irqindex].hdr = hdr; + pin_irq_hdr_tab[irqindex].mode = mode; + pin_irq_hdr_tab[irqindex].args = args; + rt_hw_interrupt_enable(level); + + return RT_EOK; +} + +static rt_err_t mm32_pin_dettach_irq(struct rt_device *device, rt_int32_t pin) +{ + rt_base_t level; + rt_int32_t irqindex = -1; + + if (PIN_PORT(pin) >= PIN_STPORT_MAX) + { + return -RT_ENOSYS; + } + + irqindex = bit2bitno(PIN_STPIN(pin)); + if (irqindex < 0 || irqindex >= ITEM_NUM(pin_irq_map)) + { + return RT_ENOSYS; + } + + level = rt_hw_interrupt_disable(); + if (pin_irq_hdr_tab[irqindex].pin == -1) + { + rt_hw_interrupt_enable(level); + return RT_EOK; + } + pin_irq_hdr_tab[irqindex].pin = -1; + pin_irq_hdr_tab[irqindex].hdr = RT_NULL; + pin_irq_hdr_tab[irqindex].mode = 0; + pin_irq_hdr_tab[irqindex].args = RT_NULL; + rt_hw_interrupt_enable(level); + + return RT_EOK; +} + +static rt_err_t mm32_pin_irq_enable(struct rt_device *device, rt_base_t pin, + rt_uint32_t enabled) +{ + const struct pin_irq_map *irqmap; + rt_base_t level; + rt_int32_t irqindex = -1; + GPIO_Init_Type GPIO_InitStruct; + + if (PIN_PORT(pin) >= PIN_STPORT_MAX) + { + return -RT_ENOSYS; + } + + if (enabled == PIN_IRQ_ENABLE) + { + irqindex = bit2bitno(PIN_STPIN(pin)); + if (irqindex < 0 || irqindex >= ITEM_NUM(pin_irq_map)) + { + return RT_ENOSYS; + } + + level = rt_hw_interrupt_disable(); + + if (pin_irq_hdr_tab[irqindex].pin == -1) + { + rt_hw_interrupt_enable(level); + return RT_ENOSYS; + } + + irqmap = &pin_irq_map[irqindex]; + + /* Configure GPIO_InitStructure */ + GPIO_InitStruct.Pins = PIN_STPIN(pin); + GPIO_InitStruct.Speed = GPIO_Speed_50MHz; + GPIO_InitStruct.PinMode = GPIO_PinMode_In_PullUp; + GPIO_Init(PIN_STPORT(pin), &GPIO_InitStruct); + + SYSCFG_SetExtIntMux(SYSCFG_EXTIPort_GPIOA + (0 == (rt_uint32_t)PIN_PORT(pin)?0: PIN_PORT(pin)/GPIOB_BASE), irqmap->syscfg_extiline); + switch (pin_irq_hdr_tab[irqindex].mode) + { + case PIN_IRQ_MODE_RISING: + EXTI_SetTriggerIn(EXTI, irqmap->extiline, EXTI_TriggerIn_RisingEdge); + break; + case PIN_IRQ_MODE_FALLING: + EXTI_SetTriggerIn(EXTI, irqmap->extiline, EXTI_TriggerIn_FallingEdge); + break; + case PIN_IRQ_MODE_RISING_FALLING: + EXTI_SetTriggerIn(EXTI, irqmap->extiline, EXTI_TriggerIn_BothEdges); + break; + } + EXTI_EnableLineInterrupt(EXTI, irqmap->extiline, true); + + NVIC_SetPriority(irqmap->irqno, NVIC_EncodePriority(4, 5, 0)); + NVIC_EnableIRQ(irqmap->irqno); + pin_irq_enable_mask |= irqmap->pinbit; + + rt_hw_interrupt_enable(level); + } + else if (enabled == PIN_IRQ_DISABLE) + { + irqmap = get_pin_irq_map(PIN_STPIN(pin)); + if (irqmap == RT_NULL) + { + return RT_ENOSYS; + } + + level = rt_hw_interrupt_disable(); + + pin_irq_enable_mask &= ~irqmap->pinbit; + + if ((irqmap->pinbit >= GPIO_PIN_5) && (irqmap->pinbit <= GPIO_PIN_9)) + { + if (!(pin_irq_enable_mask & (GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9))) + { + NVIC_DisableIRQ(irqmap->irqno); + } + } + else if ((irqmap->pinbit >= GPIO_PIN_10) && (irqmap->pinbit <= GPIO_PIN_15)) + { + if (!(pin_irq_enable_mask & (GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15))) + { + NVIC_DisableIRQ(irqmap->irqno); + } + } + else + { + NVIC_DisableIRQ(irqmap->irqno); + } + + rt_hw_interrupt_enable(level); + } + else + { + return -RT_ENOSYS; + } + + return RT_EOK; +} +const static struct rt_pin_ops _mm32_pin_ops = +{ + mm32_pin_mode, + mm32_pin_write, + mm32_pin_read, + mm32_pin_attach_irq, + mm32_pin_dettach_irq, + mm32_pin_irq_enable, + mm32_pin_get, +}; + +rt_inline void pin_irq_hdr(int irqno) +{ + if (pin_irq_hdr_tab[irqno].hdr) + { + pin_irq_hdr_tab[irqno].hdr(pin_irq_hdr_tab[irqno].args); + } +} + +void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) +{ + pin_irq_hdr(bit2bitno(GPIO_Pin)); +} + +#define __HAL_GPIO_EXTI_GET_IT(__EXTI_LINE__) (EXTI->PR & (__EXTI_LINE__)) +#define __HAL_GPIO_EXTI_CLEAR_IT(__EXTI_LINE__) (EXTI->PR = (__EXTI_LINE__)) + +void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin) +{ + /* EXTI line interrupt detected */ + if (__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != 0x00u) + { + __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin); + HAL_GPIO_EXTI_Callback(GPIO_Pin); + } +} + +void EXTI0_IRQHandler(void) +{ + rt_interrupt_enter(); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0); + rt_interrupt_leave(); +} + +void EXTI1_IRQHandler(void) +{ + rt_interrupt_enter(); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1); + rt_interrupt_leave(); +} + +void EXTI2_IRQHandler(void) +{ + rt_interrupt_enter(); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2); + rt_interrupt_leave(); +} + +void EXTI3_IRQHandler(void) +{ + rt_interrupt_enter(); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_3); + rt_interrupt_leave(); +} + +void EXTI4_IRQHandler(void) +{ + rt_interrupt_enter(); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_4); + rt_interrupt_leave(); +} + +void EXTI9_5_IRQHandler(void) +{ + rt_interrupt_enter(); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_6); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_7); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9); + rt_interrupt_leave(); +} + +void EXTI15_10_IRQHandler(void) +{ + rt_interrupt_enter(); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_10); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_11); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14); + HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15); + rt_interrupt_leave(); +} + +int rt_hw_pin_init(void) +{ +#if defined(RCC_AHB1_PERIPH_GPIOA) + RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOA, true); +#endif + +#if defined(RCC_AHB1_PERIPH_GPIOB) + RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOB, true); +#endif + +#if defined(RCC_AHB1_PERIPH_GPIOC) + RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOC, true); +#endif + +#if defined(RCC_AHB1_PERIPH_GPIOD) + RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOD, true); +#endif + +#if defined(RCC_AHB1_PERIPH_GPIOE) + RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOE, true); +#endif + +#if defined(RCC_AHB1_PERIPH_GPIOF) + RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOF, true); +#endif + +#if defined(RCC_APB2_PERIPH_SYSCFG) + RCC_EnableAPB2Periphs(RCC_APB2_PERIPH_SYSCFG, true); +#endif + + return rt_device_pin_register("pin", &_mm32_pin_ops, RT_NULL); +} + +#endif /* RT_USING_PIN */ diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_gpio.h b/bsp/mm32/libraries/HAL_Drivers/drv_gpio.h new file mode 100644 index 0000000000..50ee149737 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_gpio.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#ifndef __DRV_GPIO_H__ +#define __DRV_GPIO_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define __MM32_PORT(port) GPIO##port##_BASE + +#define GET_PIN(PORTx,PIN) (rt_base_t)((16 * ( ((rt_base_t)__MM32_PORT(PORTx) - (rt_base_t)GPIOA_BASE)/(0x0400UL) )) + PIN) + +struct pin_irq_map +{ + rt_uint16_t pinbit; + IRQn_Type irqno; + rt_uint32_t extiline; + SYSCFG_EXTILine_Type syscfg_extiline; +}; + +int rt_hw_pin_init(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __DRV_GPIO_H__ */ + diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_spi.c b/bsp/mm32/libraries/HAL_Drivers/drv_spi.c new file mode 100644 index 0000000000..45c062adf8 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_spi.c @@ -0,0 +1,833 @@ +/** + * @file drv_spi.c + * @author 100ask development team + * @brief + * @version 0.1 + * @date 2022-06-16 + * + * @copyright Copyright (c) 2022 Chongqing 100ASK Technology Co., LTD + * + */ + +#include +#include + +#define RT_USING_SPI +#define BSP_USING_SPI1 +#define BSP_SPI1_TX_USING_DMA +#define BSP_SPI1_RX_USING_DMA + +#ifdef RT_USING_SPI + +#if defined(BSP_USING_SPI1) || defined(BSP_USING_SPI2) || defined(BSP_USING_SPI3) + +#include "drv_spi.h" +#include "drv_config.h" +#include + +//#define DRV_DEBUG +#define LOG_TAG "drv.spi" +#include + +enum +{ +#ifdef BSP_USING_SPI1 + SPI1_INDEX, +#endif +#ifdef BSP_USING_SPI2 + SPI2_INDEX, +#endif +#ifdef BSP_USING_SPI3 + SPI3_INDEX, +#endif +}; + +static struct mm32_spi_config spi_config[] = +{ +#ifdef BSP_USING_SPI1 + SPI1_BUS_CONFIG, +#endif + +#ifdef BSP_USING_SPI2 + SPI2_BUS_CONFIG, +#endif + +#ifdef BSP_USING_SPI3 + SPI3_BUS_CONFIG, +#endif +}; + +static struct mm32_spi spi_bus_obj[sizeof(spi_config) / sizeof(spi_config[0])] = {0}; + +static rt_err_t mm32_spi_init(struct mm32_spi *spi_drv, struct rt_spi_configuration *cfg) +{ + RT_ASSERT(spi_drv != RT_NULL); + RT_ASSERT(cfg != RT_NULL); + + SPI_Master_Init_Type *spi_handle = &spi_drv->handle; + + spi_handle->ClockFreqHz = Drv_Get_APB1_Clock(); + + if (cfg->data_width == 8) + { + spi_handle->DataWidth = SPI_DataWidth_8b; + } + else if (cfg->data_width == 16) + { + spi_handle->DataWidth = SPI_DataWidth_8b; + } + else + { + return RT_EIO; + } + + if (cfg->mode & RT_SPI_CPOL) + { + spi_handle->PolarityPhase = SPI_PolarityPhase_Alt0; + } + else + { + spi_handle->PolarityPhase = SPI_PolarityPhase_Alt1; + } + + if (cfg->mode & RT_SPI_NO_CS) + { + spi_handle->AutoCS = RT_FALSE; + } + else + { + spi_handle->AutoCS = RT_TRUE; + } + + uint32_t SPI_APB_CLOCK; + SPI_APB_CLOCK = Drv_Get_APB1_Clock(); + + if (cfg->max_hz >= SPI_APB_CLOCK / 2) + { + spi_handle->BaudRate= (SPI_APB_CLOCK>>1); + } + else + { + spi_handle->BaudRate = cfg->max_hz; + } + + LOG_D("sys freq: %d, pclk2 freq: %d, SPI limiting freq: %d, BaudRatePrescaler: %d", + HAL_RCC_GetSysClockFreq(), + SPI_APB_CLOCK, + cfg->max_hz, + spi_handle->BaudRate); + + if (cfg->mode & RT_SPI_MSB) + { + spi_handle->LSB = RT_FALSE; + } + else + { + spi_handle->LSB = RT_TRUE; + } + + spi_handle->XferMode = SPI_XferMode_TxRx; + extern void SPI_MspInit(SPI_Type *mspi, , uint8_t autocs); + SPI_MspInit(spi_drv->config->Instance, cfg->mode & RT_SPI_NO_CS); + SPI_InitMaster(spi_drv->config->Instance, spi_handle); + + /* DMA configuration */ + extern int DMA_MspInit(DMA_Channel_Init_Type handle, \ + DMA_Type *dma, \ + uint32_t req, \ + IRQn_Type irqn, \ + rt_uint32_t rcc, \ + uint8_t *buf, \ + uint16_t buf_len); + if (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG) + { + int ret = DMA_MspInit(spi_drv->dma.handle_rx, \ + spi_drv->config->dma_rx->Instance, \ + spi_drv->config->dma_rx->dma_req, \ + spi_drv->config->dma_rx->dma_irq, \ + spi_drv->config->dma_rx->dma_rcc, \ + spi_drv->dma.rx_buf_len, \ + spi_drv->dma.rx_buf); + if(ret == -1) + { + LOG_D("%s init DMA failed.\r\n", spi_drv->config->bus_name); + return RT_ERROR; + } + SPI_EnableDMA(spi_drv->config->dma_rx->Instance, RT_TRUE); + } + + if (spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) + { + int ret = DMA_MspInit(spi_drv->dma.handle_tx, \ + spi_drv->config->dma_tx->Instance, \ + spi_drv->config->dma_tx->dma_req, \ + spi_drv->config->dma_tx->dma_irq, \ + spi_drv->config->dma_tx->dma_rcc, + spi_drv->dma.tx_buf_len, \ + spi_drv->dma.tx_buf); + if(ret == -1) + { + LOG_D("%s init DMA failed.\r\n", spi_drv->config->bus_name); + return RT_ERROR; + } + + SPI_EnableDMA(spi_drv->config->dma_tx->Instance, RT_TRUE); + } + + SPI_Enable(spi_drv->config->Instance, RT_TRUE); + + LOG_D("%s init done", spi_drv->config->bus_name); + return RT_EOK; +} + +static rt_uint32_t spixfer(struct rt_spi_device *device, struct rt_spi_message *message) +{ + HAL_StatusTypeDef state; + rt_size_t message_length, already_send_length; + rt_uint16_t send_length; + rt_uint8_t *recv_buf; + const rt_uint8_t *send_buf; + + RT_ASSERT(device != RT_NULL); + RT_ASSERT(device->bus != RT_NULL); + RT_ASSERT(device->bus->parent.user_data != RT_NULL); + RT_ASSERT(message != RT_NULL); + + struct mm32_spi *spi_drv = rt_container_of(device->bus, struct mm32_spi, spi_bus); + SPI_Master_Init_Type *spi_handle = &spi_drv->handle; + struct mm32_hw_spi_cs *cs = device->parent.user_data; + + if (message->cs_take) + { + GPIO_WriteBit(cs->GPIOx, cs->GPIO_Pin, 0); + } + + LOG_D("%s transfer prepare and start", spi_drv->config->bus_name); + LOG_D("%s sendbuf: %X, recvbuf: %X, length: %d", + spi_drv->config->bus_name, + (uint32_t)message->send_buf, + (uint32_t)message->recv_buf, message->length); + + message_length = message->length; + recv_buf = message->recv_buf; + send_buf = message->send_buf; + while (message_length) + { + /* the HAL library use uint16 to save the data length */ + if (message_length > 65535) + { + send_length = 65535; + message_length = message_length - 65535; + } + else + { + send_length = message_length; + message_length = 0; + } + + /* calculate the start address */ + already_send_length = message->length - send_length - message_length; + send_buf = (rt_uint8_t *)message->send_buf + already_send_length; + recv_buf = (rt_uint8_t *)message->recv_buf + already_send_length; + + /* start once data exchange in DMA mode */ + if (message->send_buf && message->recv_buf) + { + if ((spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) && (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG)) + { + state = HAL_SPI_TransmitReceive_DMA(spi_handle, (uint8_t *)send_buf, (uint8_t *)recv_buf, send_length); + } + else + { + state = HAL_SPI_TransmitReceive(spi_handle, (uint8_t *)send_buf, (uint8_t *)recv_buf, send_length, 1000); + } + } + else if (message->send_buf) + { + if (spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) + { + state = HAL_SPI_Transmit_DMA(spi_handle, (uint8_t *)send_buf, send_length); + } + else + { + state = HAL_SPI_Transmit(spi_handle, (uint8_t *)send_buf, send_length, 1000); + } + } + else + { + memset((uint8_t *)recv_buf, 0xff, send_length); + if (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG) + { + state = HAL_SPI_Receive_DMA(spi_handle, (uint8_t *)recv_buf, send_length); + } + else + { + state = HAL_SPI_Receive(spi_handle, (uint8_t *)recv_buf, send_length, 1000); + } + } + + if (state != HAL_OK) + { + LOG_I("spi transfer error : %d", state); + message->length = 0; + spi_handle->State = HAL_SPI_STATE_READY; + } + else + { + LOG_D("%s transfer done", spi_drv->config->bus_name); + } + + /* For simplicity reasons, this example is just waiting till the end of the + transfer, but application may perform other tasks while transfer operation + is ongoing. */ + while (HAL_SPI_GetState(spi_handle) != HAL_SPI_STATE_READY); + } + + if (message->cs_release) + { + HAL_GPIO_WritePin(cs->GPIOx, cs->GPIO_Pin, GPIO_PIN_SET); + } + + return message->length; +} + +static rt_err_t spi_configure(struct rt_spi_device *device, + struct rt_spi_configuration *configuration) +{ + RT_ASSERT(device != RT_NULL); + RT_ASSERT(configuration != RT_NULL); + + struct mm32_spi *spi_drv = rt_container_of(device->bus, struct mm32_spi, spi_bus); + spi_drv->cfg = configuration; + + return mm32_spi_init(spi_drv, configuration); +} + +static const struct rt_spi_ops stm_spi_ops = +{ + .configure = spi_configure, + .xfer = spixfer, +}; + +static int rt_hw_spi_bus_init(void) +{ + rt_err_t result; + for (int i = 0; i < sizeof(spi_config) / sizeof(spi_config[0]); i++) + { + spi_bus_obj[i].config = &spi_config[i]; + spi_bus_obj[i].spi_bus.parent.user_data = &spi_config[i]; + spi_bus_obj[i].handle.Instance = spi_config[i].Instance; + + if (spi_bus_obj[i].spi_dma_flag & SPI_USING_RX_DMA_FLAG) + { + /* Configure the DMA handler for Transmission process */ + spi_bus_obj[i].dma.handle_rx.Instance = spi_config[i].dma_rx->Instance; +#if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) + spi_bus_obj[i].dma.handle_rx.Init.Channel = spi_config[i].dma_rx->channel; +#elif defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) + spi_bus_obj[i].dma.handle_rx.Init.Request = spi_config[i].dma_rx->request; +#endif + spi_bus_obj[i].dma.handle_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; + spi_bus_obj[i].dma.handle_rx.Init.PeriphInc = DMA_PINC_DISABLE; + spi_bus_obj[i].dma.handle_rx.Init.MemInc = DMA_MINC_ENABLE; + spi_bus_obj[i].dma.handle_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; + spi_bus_obj[i].dma.handle_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; + spi_bus_obj[i].dma.handle_rx.Init.Mode = DMA_NORMAL; + spi_bus_obj[i].dma.handle_rx.Init.Priority = DMA_PRIORITY_HIGH; +#if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) + spi_bus_obj[i].dma.handle_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; + spi_bus_obj[i].dma.handle_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; + spi_bus_obj[i].dma.handle_rx.Init.MemBurst = DMA_MBURST_INC4; + spi_bus_obj[i].dma.handle_rx.Init.PeriphBurst = DMA_PBURST_INC4; +#endif + + { + rt_uint32_t tmpreg = 0x00U; +#if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32F0) + /* enable DMA clock && Delay after an RCC peripheral clock enabling*/ + SET_BIT(RCC->AHBENR, spi_config[i].dma_rx->dma_rcc); + tmpreg = READ_BIT(RCC->AHBENR, spi_config[i].dma_rx->dma_rcc); +#elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) + SET_BIT(RCC->AHB1ENR, spi_config[i].dma_rx->dma_rcc); + /* Delay after an RCC peripheral clock enabling */ + tmpreg = READ_BIT(RCC->AHB1ENR, spi_config[i].dma_rx->dma_rcc); +#endif + UNUSED(tmpreg); /* To avoid compiler warnings */ + } + } + + if (spi_bus_obj[i].spi_dma_flag & SPI_USING_TX_DMA_FLAG) + { + /* Configure the DMA handler for Transmission process */ + spi_bus_obj[i].dma.handle_tx.Instance = spi_config[i].dma_tx->Instance; +#if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) + spi_bus_obj[i].dma.handle_tx.Init.Channel = spi_config[i].dma_tx->channel; +#elif defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0) + spi_bus_obj[i].dma.handle_tx.Init.Request = spi_config[i].dma_tx->request; +#endif + spi_bus_obj[i].dma.handle_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; + spi_bus_obj[i].dma.handle_tx.Init.PeriphInc = DMA_PINC_DISABLE; + spi_bus_obj[i].dma.handle_tx.Init.MemInc = DMA_MINC_ENABLE; + spi_bus_obj[i].dma.handle_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; + spi_bus_obj[i].dma.handle_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; + spi_bus_obj[i].dma.handle_tx.Init.Mode = DMA_NORMAL; + spi_bus_obj[i].dma.handle_tx.Init.Priority = DMA_PRIORITY_LOW; +#if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) + spi_bus_obj[i].dma.handle_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; + spi_bus_obj[i].dma.handle_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; + spi_bus_obj[i].dma.handle_tx.Init.MemBurst = DMA_MBURST_INC4; + spi_bus_obj[i].dma.handle_tx.Init.PeriphBurst = DMA_PBURST_INC4; +#endif + + { + rt_uint32_t tmpreg = 0x00U; +#if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32F0) + /* enable DMA clock && Delay after an RCC peripheral clock enabling*/ + SET_BIT(RCC->AHBENR, spi_config[i].dma_tx->dma_rcc); + tmpreg = READ_BIT(RCC->AHBENR, spi_config[i].dma_tx->dma_rcc); +#elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) + SET_BIT(RCC->AHB1ENR, spi_config[i].dma_tx->dma_rcc); + /* Delay after an RCC peripheral clock enabling */ + tmpreg = READ_BIT(RCC->AHB1ENR, spi_config[i].dma_tx->dma_rcc); +#endif + UNUSED(tmpreg); /* To avoid compiler warnings */ + } + } + + result = rt_spi_bus_register(&spi_bus_obj[i].spi_bus, spi_config[i].bus_name, &stm_spi_ops); + RT_ASSERT(result == RT_EOK); + + LOG_D("%s bus init done", spi_config[i].bus_name); + } + + return result; +} + +/** + * Attach the spi device to SPI bus, this function must be used after initialization. + */ +rt_err_t rt_hw_spi_device_attach(const char *bus_name, const char *device_name, GPIO_TypeDef *cs_gpiox, uint16_t cs_gpio_pin) +{ + RT_ASSERT(bus_name != RT_NULL); + RT_ASSERT(device_name != RT_NULL); + + rt_err_t result; + struct rt_spi_device *spi_device; + struct mm32_hw_spi_cs *cs_pin; + + /* initialize the cs pin && select the slave*/ + GPIO_InitTypeDef GPIO_Initure; + GPIO_Initure.Pin = cs_gpio_pin; + GPIO_Initure.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_Initure.Pull = GPIO_PULLUP; + GPIO_Initure.Speed = GPIO_SPEED_FREQ_HIGH; + HAL_GPIO_Init(cs_gpiox, &GPIO_Initure); + HAL_GPIO_WritePin(cs_gpiox, cs_gpio_pin, GPIO_PIN_SET); + + /* attach the device to spi bus*/ + spi_device = (struct rt_spi_device *)rt_malloc(sizeof(struct rt_spi_device)); + RT_ASSERT(spi_device != RT_NULL); + cs_pin = (struct mm32_hw_spi_cs *)rt_malloc(sizeof(struct mm32_hw_spi_cs)); + RT_ASSERT(cs_pin != RT_NULL); + cs_pin->GPIOx = cs_gpiox; + cs_pin->GPIO_Pin = cs_gpio_pin; + result = rt_spi_bus_attach_device(spi_device, device_name, bus_name, (void *)cs_pin); + + if (result != RT_EOK) + { + LOG_E("%s attach to %s faild, %d\n", device_name, bus_name, result); + } + + RT_ASSERT(result == RT_EOK); + + LOG_D("%s attach to %s done", device_name, bus_name); + + return result; +} + +#if defined(BSP_SPI1_TX_USING_DMA) || defined(BSP_SPI1_RX_USING_DMA) +void SPI1_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_SPI_IRQHandler(&spi_bus_obj[SPI1_INDEX].handle); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI1) && defined(BSP_SPI1_RX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void SPI1_DMA_RX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI1_INDEX].dma.handle_rx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI1) && defined(BSP_SPI1_TX_USING_DMA) +/** + * @brief This function handles DMA Tx interrupt request. + * @param None + * @retval None + */ +void SPI1_DMA_TX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI1_INDEX].dma.handle_tx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_SPI1) && defined(BSP_SPI_USING_DMA) */ + +#if defined(BSP_SPI2_TX_USING_DMA) || defined(BSP_SPI2_RX_USING_DMA) +void SPI2_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_SPI_IRQHandler(&spi_bus_obj[SPI2_INDEX].handle); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI2) && defined(BSP_SPI2_RX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void SPI2_DMA_RX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI2_INDEX].dma.handle_rx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI2) && defined(BSP_SPI2_TX_USING_DMA) +/** + * @brief This function handles DMA Tx interrupt request. + * @param None + * @retval None + */ +void SPI2_DMA_TX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI2_INDEX].dma.handle_tx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_SPI2) && defined(BSP_SPI_USING_DMA) */ + +#if defined(BSP_SPI3_TX_USING_DMA) || defined(BSP_SPI3_RX_USING_DMA) +void SPI3_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_SPI_IRQHandler(&spi_bus_obj[SPI3_INDEX].handle); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI3) && defined(BSP_SPI3_RX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void SPI3_DMA_RX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI3_INDEX].dma.handle_rx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI3) && defined(BSP_SPI3_TX_USING_DMA) +/** + * @brief This function handles DMA Tx interrupt request. + * @param None + * @retval None + */ +void SPI3_DMA_TX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI3_INDEX].dma.handle_tx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_SPI3) && defined(BSP_SPI_USING_DMA) */ + +#if defined(BSP_SPI4_TX_USING_DMA) || defined(BSP_SPI4_RX_USING_DMA) +void SPI4_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_SPI_IRQHandler(&spi_bus_obj[SPI4_INDEX].handle); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI4) && defined(BSP_SPI4_RX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void SPI4_DMA_RX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI4_INDEX].dma.handle_rx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI4) && defined(BSP_SPI4_TX_USING_DMA) +/** + * @brief This function handles DMA Tx interrupt request. + * @param None + * @retval None + */ +void SPI4_DMA_TX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI4_INDEX].dma.handle_tx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_SPI4) && defined(BSP_SPI_USING_DMA) */ + +#if defined(BSP_SPI5_TX_USING_DMA) || defined(BSP_SPI5_RX_USING_DMA) +void SPI5_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_SPI_IRQHandler(&spi_bus_obj[SPI5_INDEX].handle); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI5) && defined(BSP_SPI5_RX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void SPI5_DMA_RX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI5_INDEX].dma.handle_rx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI5) && defined(BSP_SPI5_TX_USING_DMA) +/** + * @brief This function handles DMA Tx interrupt request. + * @param None + * @retval None + */ +void SPI5_DMA_TX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI5_INDEX].dma.handle_tx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_SPI5) && defined(BSP_SPI_USING_DMA) */ + +#if defined(BSP_USING_SPI6) && defined(BSP_SPI6_RX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void SPI6_DMA_RX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI6_INDEX].dma.handle_rx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_SPI6) && defined(BSP_SPI6_TX_USING_DMA) +/** + * @brief This function handles DMA Tx interrupt request. + * @param None + * @retval None + */ +void SPI6_DMA_TX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&spi_bus_obj[SPI6_INDEX].dma.handle_tx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_SPI6) && defined(BSP_SPI_USING_DMA) */ + +static void mm32_get_dma_info(void) +{ +#ifdef BSP_SPI1_RX_USING_DMA + spi_bus_obj[SPI1_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG; + static struct dma_config spi1_dma_rx = SPI1_RX_DMA_CONFIG; + spi_config[SPI1_INDEX].dma_rx = &spi1_dma_rx; +#endif +#ifdef BSP_SPI1_TX_USING_DMA + spi_bus_obj[SPI1_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG; + static struct dma_config spi1_dma_tx = SPI1_TX_DMA_CONFIG; + spi_config[SPI1_INDEX].dma_tx = &spi1_dma_tx; +#endif + +#ifdef BSP_SPI2_RX_USING_DMA + spi_bus_obj[SPI2_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG; + static struct dma_config spi2_dma_rx = SPI2_RX_DMA_CONFIG; + spi_config[SPI2_INDEX].dma_rx = &spi2_dma_rx; +#endif +#ifdef BSP_SPI2_TX_USING_DMA + spi_bus_obj[SPI2_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG; + static struct dma_config spi2_dma_tx = SPI2_TX_DMA_CONFIG; + spi_config[SPI2_INDEX].dma_tx = &spi2_dma_tx; +#endif + +#ifdef BSP_SPI3_RX_USING_DMA + spi_bus_obj[SPI3_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG; + static struct dma_config spi3_dma_rx = SPI3_RX_DMA_CONFIG; + spi_config[SPI3_INDEX].dma_rx = &spi3_dma_rx; +#endif +#ifdef BSP_SPI3_TX_USING_DMA + spi_bus_obj[SPI3_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG; + static struct dma_config spi3_dma_tx = SPI3_TX_DMA_CONFIG; + spi_config[SPI3_INDEX].dma_tx = &spi3_dma_tx; +#endif + +#ifdef BSP_SPI4_RX_USING_DMA + spi_bus_obj[SPI4_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG; + static struct dma_config spi4_dma_rx = SPI4_RX_DMA_CONFIG; + spi_config[SPI4_INDEX].dma_rx = &spi4_dma_rx; +#endif +#ifdef BSP_SPI4_TX_USING_DMA + spi_bus_obj[SPI4_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG; + static struct dma_config spi4_dma_tx = SPI4_TX_DMA_CONFIG; + spi_config[SPI4_INDEX].dma_tx = &spi4_dma_tx; +#endif + +#ifdef BSP_SPI5_RX_USING_DMA + spi_bus_obj[SPI5_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG; + static struct dma_config spi5_dma_rx = SPI5_RX_DMA_CONFIG; + spi_config[SPI5_INDEX].dma_rx = &spi5_dma_rx; +#endif +#ifdef BSP_SPI5_TX_USING_DMA + spi_bus_obj[SPI5_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG; + static struct dma_config spi5_dma_tx = SPI5_TX_DMA_CONFIG; + spi_config[SPI5_INDEX].dma_tx = &spi5_dma_tx; +#endif + +#ifdef BSP_SPI6_RX_USING_DMA + spi_bus_obj[SPI6_INDEX].spi_dma_flag |= SPI_USING_RX_DMA_FLAG; + static struct dma_config spi6_dma_rx = SPI6_RX_DMA_CONFIG; + spi_config[SPI6_INDEX].dma_rx = &spi6_dma_rx; +#endif +#ifdef BSP_SPI6_TX_USING_DMA + spi_bus_obj[SPI6_INDEX].spi_dma_flag |= SPI_USING_TX_DMA_FLAG; + static struct dma_config spi6_dma_tx = SPI6_TX_DMA_CONFIG; + spi_config[SPI6_INDEX].dma_tx = &spi6_dma_tx; +#endif +} + +#if defined(SOC_SERIES_STM32F0) +void SPI1_DMA_RX_TX_IRQHandler(void) +{ +#if defined(BSP_USING_SPI1) && defined(BSP_SPI1_TX_USING_DMA) + SPI1_DMA_TX_IRQHandler(); +#endif + +#if defined(BSP_USING_SPI1) && defined(BSP_SPI1_RX_USING_DMA) + SPI1_DMA_RX_IRQHandler(); +#endif +} + +void SPI2_DMA_RX_TX_IRQHandler(void) +{ +#if defined(BSP_USING_SPI2) && defined(BSP_SPI2_TX_USING_DMA) + SPI2_DMA_TX_IRQHandler(); +#endif + +#if defined(BSP_USING_SPI2) && defined(BSP_SPI2_RX_USING_DMA) + SPI2_DMA_RX_IRQHandler(); +#endif +} +#endif /* SOC_SERIES_STM32F0 */ + +int rt_hw_spi_init(void) +{ + mm32_get_dma_info(); + return rt_hw_spi_bus_init(); +} +INIT_BOARD_EXPORT(rt_hw_spi_init); + + +#endif /* BSP_USING_SPI1 || BSP_USING_SPI2 || BSP_USING_SPI3 */ + +#endif /* RT_USING_SPI */ + diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_spi.h b/bsp/mm32/libraries/HAL_Drivers/drv_spi.h new file mode 100644 index 0000000000..5dec4fd2f2 --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_spi.h @@ -0,0 +1,67 @@ +/** + * @file drv_spi.h + * @author 100ask development team + * @brief + * @version 0.1 + * @date 2022-06-16 + * + * @copyright Copyright (c) 2022 Chongqing 100ASK Technology Co., LTD + * + */ + +#ifndef __DRV_SPI_H_ +#define __DRV_SPI_H_ + +#include +#include "rtdevice.h" +#include +#include "drv_common.h" +#include "drv_dma.h" + +rt_err_t rt_hw_spi_device_attach(const char *bus_name, const char *device_name, GPIO_TypeDef* cs_gpiox, uint16_t cs_gpio_pin); + +struct mm32_hw_spi_cs +{ + GPIO_Type* GPIOx; + uint16_t GPIO_Pin; +}; + +struct mm32_spi_config +{ + SPI_Type *Instance; + char *bus_name; + struct dma_config *dma_rx, *dma_tx; +}; + +struct stm32_spi_device +{ + rt_uint32_t pin; + char *bus_name; + char *device_name; +}; + +#define SPI_USING_RX_DMA_FLAG (1<<0) +#define SPI_USING_TX_DMA_FLAG (1<<1) + +/* stm32 spi dirver class */ +struct mm32_spi +{ + SPI_Master_Init_Type handle; + struct mm32_spi_config *config; + struct rt_spi_configuration *cfg; + + struct + { + rt_uint16_t rx_buf_len; + rt_uint8_t *rx_buf; + DMA_Channel_Init_Type handle_rx; + rt_uint16_t tx_buf_len; + rt_uint8_t *tx_buf; + DMA_Channel_Init_Type handle_tx; + } dma; + + rt_uint8_t spi_dma_flag; + struct rt_spi_bus spi_bus; +}; + +#endif /* __DRV_SPI_H_ */ diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_uart.c b/bsp/mm32/libraries/HAL_Drivers/drv_uart.c new file mode 100644 index 0000000000..23928babbb --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_uart.c @@ -0,0 +1,432 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#include "board.h" +#include "drv_uart.h" +#include "drv_config.h" + +#ifdef RT_USING_SERIAL + +//#define DRV_DEBUG +#define LOG_TAG "drv.usart" + +#if !defined(BSP_USING_UART1) && !defined(BSP_USING_UART2) && !defined(BSP_USING_UART3) && \ + !defined(BSP_USING_UART4) && !defined(BSP_USING_UART5) && !defined(BSP_USING_UART6) && \ + !defined(BSP_USING_UART7) && !defined(BSP_USING_UART8) +#error "Please define at least one BSP_USING_UARTx" +/* this driver can be disabled at menuconfig -> RT-Thread Components -> Device Drivers */ +#endif + +#define __HAL_UART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->CSR & (__FLAG__)) == (__FLAG__)) +#define __HAL_UART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->CSR = ~(__FLAG__)) +#define __HAL_UART_GET_INT_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->ISR & (__FLAG__)) == (__FLAG__)) +#define __HAL_UART_CLEAR_INT_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->ICR &= (__FLAG__)) + +enum +{ +#ifdef BSP_USING_UART1 + UART1_INDEX, +#endif +#ifdef BSP_USING_UART2 + UART2_INDEX, +#endif +#ifdef BSP_USING_UART3 + UART3_INDEX, +#endif +#ifdef BSP_USING_UART4 + UART4_INDEX, +#endif +#ifdef BSP_USING_UART5 + UART5_INDEX, +#endif +#ifdef BSP_USING_UART6 + UART6_INDEX, +#endif +#ifdef BSP_USING_UART7 + UART7_INDEX, +#endif +#ifdef BSP_USING_UART8 + UART8_INDEX, +#endif +#ifdef BSP_USING_LPUART1 + LPUART1_INDEX, +#endif +}; + +static struct mm32_uart_config uart_config[] = +{ +#ifdef BSP_USING_UART1 + UART1_CONFIG, +#endif +#ifdef BSP_USING_UART2 + UART2_CONFIG, +#endif +#ifdef BSP_USING_UART3 + UART3_CONFIG, +#endif +#ifdef BSP_USING_UART4 + UART4_CONFIG, +#endif +#ifdef BSP_USING_UART5 + UART5_CONFIG, +#endif +#ifdef BSP_USING_UART6 + UART6_CONFIG, +#endif +#ifdef BSP_USING_UART7 + UART7_CONFIG, +#endif +#ifdef BSP_USING_UART8 + UART8_CONFIG, +#endif +#ifdef BSP_USING_LPUART1 + LPUART1_CONFIG, +#endif +}; + +static struct mm32_uart uart_obj[sizeof(uart_config) / sizeof(uart_config[0])] = {0}; + +static rt_err_t mm32_configure(struct rt_serial_device *serial, struct serial_configure *cfg) +{ + struct mm32_uart *uart; + RT_ASSERT(serial != RT_NULL); + RT_ASSERT(cfg != RT_NULL); + + uart = rt_container_of(serial, struct mm32_uart, serial); + uart->handle.ClockFreqHz = HAL_Get_APB2_Clock(); + uart->handle.BaudRate = cfg->baud_rate; + uart->handle.XferMode = UART_XferMode_RxTx; + + switch (cfg->flowcontrol) + { + case RT_SERIAL_FLOWCONTROL_NONE: + uart->handle.HwFlowControl = UART_HwFlowControl_None; + break; + case RT_SERIAL_FLOWCONTROL_CTSRTS: + uart->handle.HwFlowControl = UART_HwFlowControl_RTS_CTS; + break; + default: + uart->handle.HwFlowControl = UART_HwFlowControl_None; + break; + } + + switch (cfg->data_bits) + { + case DATA_BITS_5: + uart->handle.WordLength = UART_WordLength_5b; + break; + case DATA_BITS_6: + uart->handle.WordLength = UART_WordLength_6b; + break; + case DATA_BITS_7: + uart->handle.WordLength = UART_WordLength_7b; + break; + case DATA_BITS_8: + uart->handle.WordLength = UART_WordLength_8b; + break; + default: + uart->handle.WordLength = UART_WordLength_8b; + break; + } + + switch (cfg->stop_bits) + { + case STOP_BITS_1: + uart->handle.StopBits = UART_StopBits_1; + break; + case STOP_BITS_2: + uart->handle.StopBits = UART_StopBits_2; + break; + default: + uart->handle.StopBits = UART_StopBits_1; + break; + } + + switch (cfg->parity) + { + case PARITY_NONE: + uart->handle.Parity = UART_Parity_None; + break; + case PARITY_ODD: + uart->handle.Parity = UART_Parity_Odd; + break; + case PARITY_EVEN: + uart->handle.Parity = UART_Parity_Even; + break; + default: + uart->handle.Parity = UART_Parity_None; + break; + } + +#ifdef RT_SERIAL_USING_DMA + if (!(serial->parent.open_flag & RT_DEVICE_OFLAG_OPEN)) { + uart->dma_rx.last_index = 0; + } +#endif + extern void UART_MspInit(UART_Type *muart); + UART_MspInit(uart->config->Instance); + UART_Init(uart->config->Instance, &uart->handle); + UART_Enable(uart->config->Instance, true); + + return RT_EOK; +} + +static rt_err_t mm32_control(struct rt_serial_device *serial, int cmd, void *arg) +{ + struct mm32_uart *uart; + rt_uint32_t prioritygroup = 0x00U; +#ifdef RT_SERIAL_USING_DMA + rt_ubase_t ctrl_arg = (rt_ubase_t)arg; +#endif + + RT_ASSERT(serial != RT_NULL); + uart = rt_container_of(serial, struct mm32_uart, serial); + + switch (cmd) + { + /* disable interrupt */ + case RT_DEVICE_CTRL_CLR_INT: + /* disable rx irq */ + NVIC_DisableIRQ(uart->config->irq_type); + +#ifdef RT_SERIAL_USING_DMA + /* disable DMA */ + if (ctrl_arg == RT_DEVICE_FLAG_DMA_RX) + { + + } + else if(ctrl_arg == RT_DEVICE_FLAG_DMA_TX) + { + + } +#endif + break; + + /* enable interrupt */ + case RT_DEVICE_CTRL_SET_INT: + /* enable rx irq */ + UART_EnableInterrupts(uart->config->Instance, UART_INT_RX_DONE, true); + prioritygroup = NVIC_GetPriorityGrouping(); + NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(prioritygroup, 1, 0)); + NVIC_EnableIRQ(uart->config->irq_type); + break; + +#ifdef RT_SERIAL_USING_DMA + case RT_DEVICE_CTRL_CONFIG: + + break; +#endif + + case RT_DEVICE_CTRL_CLOSE: + + break; + + } + return RT_EOK; +} + +rt_uint32_t mm32_uart_get_mask(rt_uint32_t word_length, rt_uint32_t parity) +{ + rt_uint32_t mask; + if (word_length == UART_WordLength_8b) + { + if (parity == UART_Parity_None) + { + mask = 0x00FFU ; + } + else + { + mask = 0x007FU ; + } + } + +#ifdef UART_WORDLENGTH_7B + else if (word_length == UART_WordLength_7b) + { + if (parity == UART_Parity_None) + { + mask = 0x007FU ; + } + else + { + mask = 0x003FU ; + } + } + else + { + mask = 0x0000U; + } +#endif + return mask; +} + +static int mm32_putc(struct rt_serial_device *serial, char c) +{ + struct mm32_uart *uart; + RT_ASSERT(serial != RT_NULL); + + uart = rt_container_of(serial, struct mm32_uart, serial); + + uart->config->Instance->TDR = c; + + while ( 0u == (UART_STATUS_TX_EMPTY & UART_GetStatus(uart->config->Instance)) ) + {} + return 1; +} + +static int mm32_getc(struct rt_serial_device *serial) +{ + int ch; + struct mm32_uart *uart; + RT_ASSERT(serial != RT_NULL); + uart = rt_container_of(serial, struct mm32_uart, serial); + + ch = -1; + if ((UART_STATUS_RX_DONE & UART_GetStatus(uart->config->Instance)) != 0) + { + + ch = uart->config->Instance->RDR & mm32_uart_get_mask(uart->handle.WordLength, uart->handle.Parity); + } + return ch; +} + +/** + * Uart common interrupt process. This need add to uart ISR. + * + * @param serial serial device + */ +static void uart_isr(struct rt_serial_device *serial) +{ + struct mm32_uart *uart; +#ifdef RT_SERIAL_USING_DMA + rt_size_t recv_total_index, recv_len; + rt_base_t level; +#endif + + RT_ASSERT(serial != RT_NULL); + uart = rt_container_of(serial, struct mm32_uart, serial); + + /* UART in mode Receiver -------------------------------------------------*/ + if ( (0u != __HAL_UART_GET_INT_FLAG(uart->config->Instance, UART_INT_RX_DONE)) + && (0u != __HAL_UART_GET_FLAG(uart->config->Instance, UART_STATUS_RX_DONE)) ) + { + rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND); + } +#ifdef RT_SERIAL_USING_DMA + +#endif + else + { + if (__HAL_UART_GET_FLAG(uart->config->Instance, UART_STATUS_RX_DONE) != 0) + { + __HAL_UART_CLEAR_FLAG(uart->config->Instance, UART_STATUS_RX_DONE); + } + if (__HAL_UART_GET_FLAG(uart->config->Instance, UART_STATUS_TX_DONE) != 0) + { + __HAL_UART_CLEAR_FLAG(uart->config->Instance, UART_STATUS_TX_DONE); + } + if (__HAL_UART_GET_FLAG(uart->config->Instance, UART_STATUS_TX_FULL) != 0) + { + __HAL_UART_CLEAR_FLAG(uart->config->Instance, UART_STATUS_TX_FULL); + } + if (__HAL_UART_GET_FLAG(uart->config->Instance, UART_STATUS_TX_EMPTY) != 0) + { + __HAL_UART_CLEAR_FLAG(uart->config->Instance, UART_STATUS_TX_EMPTY); + } + + if (__HAL_UART_GET_INT_FLAG(uart->config->Instance, UART_INT_RX_DONE) != 0) + { + __HAL_UART_CLEAR_INT_FLAG(uart->config->Instance, UART_INT_RX_DONE); + } + if (__HAL_UART_GET_INT_FLAG(uart->config->Instance, UART_INT_TX_DONE) != 0) + { + __HAL_UART_CLEAR_INT_FLAG(uart->config->Instance, UART_INT_TX_DONE); + } + if (__HAL_UART_GET_INT_FLAG(uart->config->Instance, UART_INT_TX_EMPTY) != 0) + { + __HAL_UART_CLEAR_INT_FLAG(uart->config->Instance, UART_INT_TX_EMPTY); + } + } +} + +#if defined(BSP_USING_UART1) +void UART1_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + uart_isr(&(uart_obj[UART1_INDEX].serial)); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + + +#if defined(BSP_USING_UART2) +void UART2_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + uart_isr(&(uart_obj[UART2_INDEX].serial)); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +#if defined(BSP_USING_UART3) +void UART3_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + uart_isr(&(uart_obj[UART3_INDEX].serial)); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif + +static const struct rt_uart_ops mm32_uart_ops = +{ + .configure = mm32_configure, + .control = mm32_control, + .putc = mm32_putc, + .getc = mm32_getc, + .dma_transmit = RT_NULL +}; + +int rt_hw_uart_init(void) +{ + rt_size_t obj_num = sizeof(uart_obj) / sizeof(struct mm32_uart); + struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT; + rt_err_t result = 0; + + for (int i = 0; i < obj_num; i++) + { + /* init UART object */ + uart_obj[i].config = &uart_config[i]; + uart_obj[i].serial.ops = &mm32_uart_ops; + uart_obj[i].serial.config = config; + + /* register UART device */ + result = rt_hw_serial_register(&uart_obj[i].serial, uart_obj[i].config->name, + RT_DEVICE_FLAG_RDWR + | RT_DEVICE_FLAG_INT_RX + | RT_DEVICE_FLAG_INT_TX + | uart_obj[i].uart_dma_flag + , NULL); + RT_ASSERT(result == RT_EOK); + } + + return result; +} + +#endif /* RT_USING_SERIAL */ diff --git a/bsp/mm32/libraries/HAL_Drivers/drv_uart.h b/bsp/mm32/libraries/HAL_Drivers/drv_uart.h new file mode 100644 index 0000000000..b6ab7dec3f --- /dev/null +++ b/bsp/mm32/libraries/HAL_Drivers/drv_uart.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#ifndef __DRV_USART_H__ +#define __DRV_USART_H__ + +#include +#include "rtdevice.h" +#include +#include + +int rt_hw_uart_init(void); + +#define DMA_INSTANCE_TYPE MA_Channel_TypeDef + +#define UART_INSTANCE_CLEAR_FUNCTION __HAL_UART_CLEAR_FLAG + + +/* stm32 config class */ +struct mm32_uart_config +{ + const char *name; + UART_Type *Instance; + IRQn_Type irq_type; + struct dma_config *dma_rx; + struct dma_config *dma_tx; +}; + +/* stm32 uart dirver class */ +struct mm32_uart +{ + UART_Init_Type handle; + struct mm32_uart_config *config; + +#ifdef RT_SERIAL_USING_DMA + struct + { + DMA_Type handle; + rt_size_t last_index; + } dma_rx; +#endif + rt_uint16_t uart_dma_flag; + struct rt_serial_device serial; +}; + +#endif /* __DRV_USART_H__ */ diff --git a/bsp/mm32/libraries/Kconfig b/bsp/mm32/libraries/Kconfig new file mode 100644 index 0000000000..2d7380e4a2 --- /dev/null +++ b/bsp/mm32/libraries/Kconfig @@ -0,0 +1,7 @@ +config SOC_FAMILY_MM32 + bool + +config SOC_SERIES_MM32F3277 + bool + select ARCH_ARM_CORTEX_M3 + select SOC_FAMILY_MM32 \ No newline at end of file diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/hal_device_registers.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/hal_device_registers.h new file mode 100644 index 0000000000..8a4d0ba69a --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/hal_device_registers.h @@ -0,0 +1,18 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#ifndef __HAL_DEVICE_REGISTER_H__ +#define __HAL_DEVICE_REGISTER_H__ + +//#include "./mm32f327x/mm32_device.h" + +#include "mm32f3277g.h" +#include "mm32f3277g_features.h" +#include "system_mm32f3277g.h" + +#endif /* __HAL_DEVICE_REGISTER_H__ */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g.h new file mode 100644 index 0000000000..1c1436e0ac --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g.h @@ -0,0 +1,9587 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#ifndef __MM32F3277G_H__ +#define __MM32F3277G_H__ + +/* ---------------------------------------------------------------------------- + -- Interrupt vector numbers + ---------------------------------------------------------------------------- */ + +/*! + * @addtogroup Interrupt_vector_numbers Interrupt vector numbers + * @{ + */ + +/** Interrupt Number Definitions */ +#define NUMBER_OF_INT_VECTORS 76 /**< Number of interrupts in the Vector table */ + +typedef enum IRQ { + NMI_IRQn = -14, /*!< Non Maskable Interrupt */ + HardFault_IRQn = -13, /*!< Cortex-M3 SV Hard Fault Interrupt */ + MemManage_IRQn = -12, /*!< Cortex-M3 Memory Management Interrupt */ + BusFault_IRQn = -11, /*!< Cortex-M3 Bus Fault Interrupt */ + UsageFault_IRQn = -10, /*!< Cortex-M3 Usage Fault Interrupt */ + SVCall_IRQn = -4, /*!< Cortex-M3 SV Call Interrupt */ + DebugMonitor_IRQn = -3, /*!< Cortex-M3 Debug Monitor Interrupt */ + PendSV_IRQn = -2, /*!< Cortex-M3 Pend SV Interrupt */ + SysTick_IRQn = -1, /*!< Cortex-M3 System Tick Interrupt */ + WWDG_IWDG_IRQn = 0, /*!< Window watchdog interrupt */ + PVD_VDT_IRQn = 1, /*!< (PVD) and (VDT) interrupt */ + TAMPER_IRQn = 2, /*!< Intrusion detection interrupted */ + RTC_IRQn = 3, /*!< RTC global interrupt */ + FLASH_IRQn = 4, /*!< Flash global interrupt */ + RCC_CRS_IRQn = 5, /*!< RCC and CRS global interrupt */ + EXTI0_IRQn = 6, /*!< EXTI line 0 interrupt */ + EXTI1_IRQn = 7, /*!< EXTI line 1 interrupted */ + EXTI2_IRQn = 8, /*!< EXTI line 2 interrupted */ + EXTI3_IRQn = 9, /*!< EXTI line 3 interrupted */ + EXTI4_IRQn = 10, /*!< EXTI line 4 interrupted */ + DMA1_CH1_IRQn = 11, /*!< DMA1 channel 1 global interrupt */ + DMA1_CH2_IRQn = 12, /*!< DMA1 channel 2 global interrupt */ + DMA1_CH3_IRQn = 13, /*!< DMA1 channel 3 global interrupt */ + DMA1_CH4_IRQn = 14, /*!< DMA1 channel 4 global interrupt */ + DMA1_CH5_IRQn = 15, /*!< DMA1 channel 5 global interrupt */ + DMA1_CH6_IRQn = 16, /*!< DMA1 channel 6 global interrupt */ + DMA1_CH7_IRQn = 17, /*!< DMA1 channel 7 global interrupt */ + ADC1_ADC2_IRQn = 18, /*!< ADC1 and ADC2 global interrupt */ + Cache_IRQn = 19, /*!< Cache global interrupt */ + CAN1_RX_IRQn = 21, /*!< CAN1 accept interrupt */ + EXTI9_5_IRQn = 23, /*!< EXTI line [9:5] is interrupted */ + TIM1_BRK_IRQn = 24, /*!< TIM1 brake interruption */ + TIM1_UP_IRQn = 25, /*!< TIM1 update interrupt */ + TIM1_TRG_COM_IRQn = 26, /*!< TIM1 trigger, communication interruption */ + TIM1_CC_IRQn = 27, /*!< TIM1 capture compare interrupt */ + TIM2_IRQn = 28, /*!< TIM2 global interrupt */ + TIM3_IRQn = 29, /*!< TIM3 global interrupt */ + TIM4_IRQn = 30, /*!< TIM4 global interrupt */ + I2C1_IRQn = 31, /*!< I2C1 global interrupt */ + I2C2_IRQn = 33, /*!< I2C2 global interrupt */ + SPI1_IRQn = 35, /*!< SPI1 global interrupt */ + SPI2_IRQn = 36, /*!< SPI2 global interrupt */ + UART1_IRQn = 37, /*!< UART1 global interrupt */ + UART2_IRQn = 38, /*!< UART2 global interrupt */ + UART3_IRQn = 39, /*!< UART3 global interrupt */ + EXTI15_10_IRQn = 40, /*!< EXTI line [15:10] is interrupted */ + RTC_Alarm_IRQn = 41, /*!< RTC alarm interrupt */ + USB_WKUP_IRQn = 42, /*!< USB wakeup interrupt */ + TIM8_BRK_IRQn = 43, /*!< TIM8 brake interruption */ + TIM8_UP_IRQn = 44, /*!< TIM8 update interrupt */ + TIM8_TRG_COM_IRQn = 45, /*!< TIM8 trigger, communication interruption */ + TIM8_CC_IRQn = 46, /*!< TIM8 capture compare interrupt */ + ADC3_IRQn = 47, /*!< ADC3 global interrupt */ + SDIO_IRQn = 49, /*!< SDIO global interrupt */ + TIM5_IRQn = 50, /*!< TIM5 global interrupt */ + SPI3_IRQn = 51, /*!< SPI3 global interrupt */ + UART4_IRQn = 52, /*!< UART4 global interrupt */ + UART5_IRQn = 53, /*!< UART5 global interrupt */ + TIM6_IRQn = 54, /*!< TIM6 global interrupt */ + TIM7_IRQn = 55, /*!< TIM7 global interrupt */ + DMA2_CH1_IRQn = 56, /*!< DMA2 channel 1 global interrupt */ + DMA2_CH2_IRQn = 57, /*!< DMA2 channel 2 global interrupt */ + DMA2_CH3_IRQn = 58, /*!< DMA2 channel 3 global interrupt */ + DMA2_CH4_IRQn = 59, /*!< DMA2 channel 4 global interrupt */ + DMA2_CH5_IRQn = 60, /*!< DMA2 channel 5 global interrupt */ + ETHERNET_MAC_IRQn = 61, /*!< ETHERNET global interrupt */ + COMP1_2_IRQn = 64, /*!< Comparator 1/2 interrupt */ + USB_FS_IRQn = 67, /*!< USB FS global interrupt */ + UART6_IRQn = 71, /*!< UART6 global interrupt */ + UART7_IRQn = 82, /*!< UART7 global interrupt */ + UART8_IRQn = 83, /*!< UART8 global interrupt */ +} IRQn_Type; + +/*! + * @} + */ /* end of group Interrupt_vector_numbers */ + + +/* ---------------------------------------------------------------------------- + -- Cortex M3 Core Configuration + ---------------------------------------------------------------------------- */ + +/*! + * @addtogroup Cortex_Core_Configuration Cortex M33 Core Configuration + * @{ + */ + +#define __MPU_PRESENT 0 /**< Defines if an MPU is present or not */ +#define __NVIC_PRIO_BITS 3 /**< Number of priority bits implemented in the NVIC */ +#define __Vendor_SysTickConfig 0 /**< Vendor specific implementation of SysTickConfig is defined */ +#define __FPU_PRESENT 0 /**< Defines if an FPU is present or not */ +#define __DSP_PRESENT 0 /**< Defines if Armv8-M Mainline core supports DSP instructions */ +#define __SAUREGION_PRESENT 0 /**< Defines if an SAU is present or not */ + +#include "core_cm3.h" /* Core Peripheral Access Layer */ + +/*! + * @} + */ /* end of group Cortex_Core_Configuration */ + + + + +/* ---------------------------------------------------------------------------- + -- Device Peripheral Access Layer + ---------------------------------------------------------------------------- */ + +/*! + * @addtogroup Peripheral_access_layer Device Peripheral Access Layer + * @{ + */ + + +/* +** Start of section using anonymous unions +*/ + +#if defined(__ARMCC_VERSION) + #if (__ARMCC_VERSION >= 6010050) + #pragma clang diagnostic push + #else + #pragma push + #pragma anon_unions + #endif +#elif defined(__GNUC__) + /* anonymous unions are enabled by default */ +#elif defined(__IAR_SYSTEMS_ICC__) + #pragma language=extended +#else + #error Not supported compiler type +#endif + +/* 定义大存储块映射基址 */ +#define FLASH_ADDR_BASE 0x08000000u +#define EEPROM_BASE 0x08100000u +#define SRAM_BASE 0x20000000u + +#define APB1_BASE 0x40000000u +#define APB2_BASE 0x40010000u + +#define AHB1_1_BASE 0x40020000u +#define AHB1_2_BASE 0x40040000u +#define AHB2_BASE 0x50000000u +#define AHB3_BASE 0x60000000u + +#define FSMC_BANK0_BASE 0x60000000u +#define FSMC_BANK1_BASE 0x64000000u +#define FSMC_BANK2_BASE 0x68000000u +#define FSMC_BANK3_BASE 0x6C000000u +/* 定义外设模块映射基址 */ + +#define TIM2_BASE (APB1_BASE) +#define TIM3_BASE (APB1_BASE + 0x0400) +#define TIM4_BASE (APB1_BASE + 0x0800) +#define TIM5_BASE (APB1_BASE + 0x0C00) +#define TIM6_BASE (APB1_BASE + 0x1000) +#define TIM7_BASE (APB1_BASE + 0x1400) +#define RTC_BKP_BASE (APB1_BASE + 0x2800) +#define WWDG_BASE (APB1_BASE + 0x2C00) +#define IWDG_BASE (APB1_BASE + 0x3000) +#define SPI2_BASE (APB1_BASE + 0x3800) +#define SPI3_BASE (APB1_BASE + 0x3C00) +#define UART2_BASE (APB1_BASE + 0x4400) +#define UART3_BASE (APB1_BASE + 0x4800) +#define UART4_BASE (APB1_BASE + 0x4C00) +#define UART5_BASE (APB1_BASE + 0x5000) +#define I2C1_BASE (APB1_BASE + 0x5400) +#define I2C2_BASE (APB1_BASE + 0x5800) +#define CAN_BASE (APB1_BASE + 0x6400) +#define CRS_BASE (APB1_BASE + 0x6C00) +#define PWR_BASE (APB1_BASE + 0x7000) +#define DAC_BASE (APB1_BASE + 0x7400) +#define UART7_BASE (APB1_BASE + 0x7800) +#define UART8_BASE (APB1_BASE + 0x7C00) + +#define SYSCFG_BASE (APB2_BASE) +#define EXTI_BASE (APB2_BASE + 0x0400) +#define ADC1_BASE (APB2_BASE + 0x2400) +#define ADC2_BASE (APB2_BASE + 0x2800) +#define TIM1_BASE (APB2_BASE + 0x2C00) +#define SPI1_BASE (APB2_BASE + 0x3000) +#define TIM8_BASE (APB2_BASE + 0x3400) +#define UART1_BASE (APB2_BASE + 0x3800) +#define UART6_BASE (APB2_BASE + 0x3C00) +#define COMP_BASE (APB2_BASE + 0x4000) +#define ADC3_BASE (APB2_BASE + 0x4C00) +#define CACHE_BASE (APB2_BASE + 0x6000) +#define SDIO_BASE (APB2_BASE + 0x8000) + +#define DMA1_BASE (AHB1_1_BASE) +#define DMA2_BASE (AHB1_1_BASE + 0x0400) +#define RCC_BASE (AHB1_1_BASE + 0x1000) +#define FLASH_BASE (AHB1_1_BASE + 0x2000) +#define CRC_BASE (AHB1_1_BASE + 0x3000) +#define ETHERNET_BASE (AHB1_1_BASE + 0x8000) + +#define GPIOA_BASE (AHB1_2_BASE) +#define GPIOB_BASE (AHB1_2_BASE + 0x400) +#define GPIOC_BASE (AHB1_2_BASE + 0x800) +#define GPIOD_BASE (AHB1_2_BASE + 0xC00) +#define GPIOE_BASE (AHB1_2_BASE + 0x1000) +#define GPIOF_BASE (AHB1_2_BASE + 0x1400) +#define GPIOG_BASE (AHB1_2_BASE + 0x1800) +#define GPIOH_BASE (AHB1_2_BASE + 0x1C00) + +#define USB_FS_OTG_BASE (AHB2_BASE) + +#define FSMC_BASE (AHB3_BASE + 0x40000000) + +/*! + * @addtogroup FLASH_Peripheral_Access_Layer FLASH Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * FLASH Type + ******************************************************************************/ +typedef struct { + __IO uint32_t ACR; ///< Flash access control register offset: 0x00 + __IO uint32_t KEYR; ///< FPEC key register offset: 0x04 + __IO uint32_t OPTKEYR; ///< Flash OPTKEY register offset: 0x08 + __IO uint32_t SR; ///< Flash Status Register offset: 0x0C + __IO uint32_t CR; ///< Flash control register offset: 0x10 + __IO uint32_t AR; ///< Flash address register offset: 0x14 + __IO uint32_t Reserved0[1]; ///< Reserved + __IO uint32_t OBR; ///< Option byte register offset: 0x1C + __IO uint32_t WRPR; ///< Write protection register offset: 0x20 +} FLASH_Type; + +/******************************************************************************* + * FLASH Type + ******************************************************************************/ + +/*! + * @addtogroup FLASH_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief FLASH_ACR Register Bit Definition + */ + +#define FLASH_ACR_PRFTBS_SHIFT (5) +#define FLASH_ACR_PRFTBS_MASK (0x01U << FLASH_ACR_PRFTBS_SHIFT) +#define FLASH_ACR_PRFTBS(x) (((uint32_t)(((uint32_t)(x)) << FLASH_ACR_PRFTBS_SHIFT)) & FLASH_ACR_PRFTBS_MASK) + +#define FLASH_ACR_PRFTBE_SHIFT (4) +#define FLASH_ACR_PRFTBE_MASK (0x01U << FLASH_ACR_PRFTBE_SHIFT) +#define FLASH_ACR_PRFTBE(x) (((uint32_t)(((uint32_t)(x)) << FLASH_ACR_PRFTBE_SHIFT)) & FLASH_ACR_PRFTBE_MASK) + +#define FLASH_ACR_LATENCY_SHIFT (0) +#define FLASH_ACR_LATENCY_MASK (0x7U << FLASH_ACR_LATENCY_SHIFT) +#define FLASH_ACR_LATENCY(x) (((uint32_t)(((uint32_t)(x)) << FLASH_ACR_LATENCY_SHIFT)) & FLASH_ACR_LATENCY_MASK) + +/*! + * @brief FLASH_KEYR Register Bit Definition + */ + +#define FLASH_KEYR_FKEYR_SHIFT (0) +#define FLASH_KEYR_FKEYR_MASK (0xFFFFFFFFU << FLASH_KEYR_FKEYR_SHIFT) +#define FLASH_KEYR_FKEYR(x) (((uint32_t)(((uint32_t)(x)) << FLASH_KEYR_FKEYR_SHIFT)) & FLASH_KEYR_FKEYR_MASK) + +/*! + * @brief FLASH_OPTKEYR Register Bit Definition + */ + +#define FLASH_OPTKEYR_OPTKEYR_SHIFT (0) +#define FLASH_OPTKEYR_OPTKEYR_MASK (0xFFFFFFFFU << FLASH_OPTKEYR_OPTKEYR_SHIFT) +#define FLASH_OPTKEYR_OPTKEYR(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OPTKEYR_OPTKEYR_SHIFT)) & FLASH_OPTKEYR_OPTKEYR_MASK) + +/*! + * @brief FLASH_SR Register Bit Definition + */ + +#define FLASH_SR_EOP_SHIFT (5) +#define FLASH_SR_EOP_MASK (0x01U << FLASH_SR_EOP_SHIFT) +#define FLASH_SR_EOP(x) (((uint32_t)(((uint32_t)(x)) << FLASH_SR_EOP_SHIFT)) & FLASH_SR_EOP_MASK) + +#define FLASH_SR_WRPRTERR_SHIFT (4) +#define FLASH_SR_WRPRTERR_MASK (0x01U << FLASH_SR_WRPRTERR_SHIFT) +#define FLASH_SR_WRPRTERR(x) (((uint32_t)(((uint32_t)(x)) << FLASH_SR_WRPRTERR_SHIFT)) & FLASH_SR_WRPRTERR_MASK) + +#define FLASH_SR_PGERR_SHIFT (2) +#define FLASH_SR_PGERR_MASK (0x01U << FLASH_SR_PGERR_SHIFT) +#define FLASH_SR_PGERR(x) (((uint32_t)(((uint32_t)(x)) << FLASH_SR_PGERR_SHIFT)) & FLASH_SR_PGERR_MASK) + +#define FLASH_SR_BSY_SHIFT (0) +#define FLASH_SR_BSY_MASK (0x01U << FLASH_SR_BSY_SHIFT) +#define FLASH_SR_BSY(x) (((uint32_t)(((uint32_t)(x)) << FLASH_SR_BSY_SHIFT)) & FLASH_SR_BSY_MASK) + +/*! + * @brief FLASH_CR Register Bit Definition + */ + +#define FLASH_CR_OPTWRE_SHIFT (9) +#define FLASH_CR_OPTWRE_MASK (0x01U << FLASH_CR_OPTWRE_SHIFT) +#define FLASH_CR_OPTWRE(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_OPTWRE_SHIFT)) & FLASH_CR_OPTWRE_MASK) + +#define FLASH_CR_LOCK_SHIFT (7) +#define FLASH_CR_LOCK_MASK (0x01U << FLASH_CR_LOCK_SHIFT) +#define FLASH_CR_LOCK(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_LOCK_SHIFT)) & FLASH_CR_LOCK_MASK) + +#define FLASH_CR_STRT_SHIFT (6) +#define FLASH_CR_STRT_MASK (0x01U << FLASH_CR_STRT_SHIFT) +#define FLASH_CR_STRT(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_STRT_SHIFT)) & FLASH_CR_STRT_MASK) + +#define FLASH_CR_OPTER_SHIFT (5) +#define FLASH_CR_OPTER_MASK (0x01U << FLASH_CR_OPTER_SHIFT) +#define FLASH_CR_OPTER(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_OPTER_SHIFT)) & FLASH_CR_OPTER_MASK) + +#define FLASH_CR_OPTPG_SHIFT (4) +#define FLASH_CR_OPTPG_MASK (0x01U << FLASH_CR_OPTPG_SHIFT) +#define FLASH_CR_OPTPG(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_OPTPG_SHIFT)) & FLASH_CR_OPTPG_MASK) + +#define FLASH_CR_MER_SHIFT (2) +#define FLASH_CR_MER_MASK (0x01U << FLASH_CR_MER_SHIFT) +#define FLASH_CR_MER(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_MER_SHIFT)) & FLASH_CR_MER_MASK) + +#define FLASH_CR_PER_SHIFT (1) +#define FLASH_CR_PER_MASK (0x01U << FLASH_CR_PER_SHIFT) +#define FLASH_CR_PER(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_PER_SHIFT)) & FLASH_CR_PER_MASK) + +#define FLASH_CR_PG_SHIFT (0) +#define FLASH_CR_PG_MASK (0x01U << FLASH_CR_PG_SHIFT) +#define FLASH_CR_PG(x) (((uint32_t)(((uint32_t)(x)) << FLASH_CR_PG_SHIFT)) & FLASH_CR_PG_MASK) + +/*! + * @brief FLASH_AR Register Bit Definition + */ + +#define FLASH_AR_FAR_SHIFT (0) +#define FLASH_AR_FAR_MASK (0xFFFFFFFFU << FLASH_AR_FAR_SHIFT) +#define FLASH_AR_FAR(x) (((uint32_t)(((uint32_t)(x)) << FLASH_AR_FAR_SHIFT)) & FLASH_AR_FAR_MASK) + +/*! + * @brief FLASH_OBR Register Bit Definition + */ + +#define FLASH_OBR_DATA1_SHIFT (18) +#define FLASH_OBR_DATA1_MASK (0xFFU << FLASH_OBR_DATA1_SHIFT) +#define FLASH_OBR_DATA1(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_DATA1_SHIFT)) & FLASH_OBR_DATA1_MASK) + +#define FLASH_OBR_DATA0_SHIFT (10) +#define FLASH_OBR_DATA0_MASK (0xFFU << FLASH_OBR_DATA0_SHIFT) +#define FLASH_OBR_DATA0(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_DATA0_SHIFT)) & FLASH_OBR_DATA0_MASK) + +#define FLASH_OBR_NBOOT1_SHIFT (6) +#define FLASH_OBR_NBOOT1_MASK (0x01U << FLASH_OBR_NBOOT1_SHIFT) +#define FLASH_OBR_NBOOT1(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_NBOOT1_SHIFT)) & FLASH_OBR_NBOOT1_MASK) + +#define FLASH_OBR_NRSTSTDBY_SHIFT (4) +#define FLASH_OBR_NRSTSTDBY_MASK (0x01U << FLASH_OBR_NRSTSTDBY_SHIFT) +#define FLASH_OBR_NRSTSTDBY(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_NRSTSTDBY_SHIFT)) & FLASH_OBR_NRSTSTDBY_MASK) + +#define FLASH_OBR_NRSTSTOP_SHIFT (3) +#define FLASH_OBR_NRSTSTOP_MASK (0x01U << FLASH_OBR_NRSTSTOP_SHIFT) +#define FLASH_OBR_NRSTSTOP(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_NRSTSTOP_SHIFT)) & FLASH_OBR_NRSTSTOP_MASK) + +#define FLASH_OBR_WDGSW_SHIFT (2) +#define FLASH_OBR_WDGSW_MASK (0x01U << FLASH_OBR_WDGSW_SHIFT) +#define FLASH_OBR_WDGSW(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_WDGSW_SHIFT)) & FLASH_OBR_WDGSW_MASK) + +#define FLASH_OBR_RDPRT_SHIFT (1) +#define FLASH_OBR_RDPRT_MASK (0x01U << FLASH_OBR_RDPRT_SHIFT) +#define FLASH_OBR_RDPRT(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_RDPRT_SHIFT)) & FLASH_OBR_RDPRT_MASK) + +#define FLASH_OBR_OPTERR_SHIFT (0) +#define FLASH_OBR_OPTERR_MASK (0x01U << FLASH_OBR_OPTERR_SHIFT) +#define FLASH_OBR_OPTERR(x) (((uint32_t)(((uint32_t)(x)) << FLASH_OBR_OPTERR_SHIFT)) & FLASH_OBR_OPTERR_MASK) + +/*! + * @brief FLASH_WRPR Register Bit Definition + */ + +#define FLASH_WRPR_WRP_SHIFT (0) +#define FLASH_WRPR_WRP_MASK (0xFFFFFFFFU << FLASH_WRPR_WRP_SHIFT) +#define FLASH_WRPR_WRP(x) (((uint32_t)(((uint32_t)(x)) << FLASH_WRPR_WRP_SHIFT)) & FLASH_WRPR_WRP_MASK) + +/*! + * @} + */ /* end of group FLASH_Register_Masks */ +/****************************************************************************** + * FLASH Instance +******************************************************************************/ +#define FLASH ((FLASH_Type*)FLASH_BASE) + +/*! + * @} + */ /* end of group FLASH_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup CACHE_Peripheral_Access_Layer CACHE Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * CACHE Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CCR; ///< Configuration and control register offset: 0x00 + __IO uint32_t SR; ///< Status register offset: 0x04 + __IO uint32_t IMR; ///< Interrupt mask register offset: 0x08 + __IO uint32_t ISR; ///< Interrupt status register offset: 0x0C + __IO uint32_t Reserved1[1]; ///< Reserved + __IO uint32_t CSHR; ///< Hit Statistics Register offset: 0x14 + __IO uint32_t CSMR; ///< Lost Statistics Register offset: 0x18 +} CACHE_Type; + +/******************************************************************************* + * CACHE Type + ******************************************************************************/ + +/*! + * @addtogroup CACHE_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief CACHE_CCR Register Bit Definition + */ + +#define CACHE_CCR_STATISTICEN_SHIFT (6) +#define CACHE_CCR_STATISTICEN_MASK (0x01U << CACHE_CCR_STATISTICEN_SHIFT) +#define CACHE_CCR_STATISTICEN(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CCR_STATISTICEN_SHIFT)) & CACHE_CCR_STATISTICEN_MASK) + +#define CACHE_CCR_SETPREFETCH_SHIFT (5) +#define CACHE_CCR_SETPREFETCH_MASK (0x01U << CACHE_CCR_SETPREFETCH_SHIFT) +#define CACHE_CCR_SETPREFETCH(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CCR_SETPREFETCH_SHIFT)) & CACHE_CCR_SETPREFETCH_MASK) + +#define CACHE_CCR_SETMANINV_SHIFT (4) +#define CACHE_CCR_SETMANINV_MASK (0x01U << CACHE_CCR_SETMANINV_SHIFT) +#define CACHE_CCR_SETMANINV(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CCR_SETMANINV_SHIFT)) & CACHE_CCR_SETMANINV_MASK) + +#define CACHE_CCR_SETMANPOW_SHIFT (3) +#define CACHE_CCR_SETMANPOW_MASK (0x01U << CACHE_CCR_SETMANPOW_SHIFT) +#define CACHE_CCR_SETMANPOW(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CCR_SETMANPOW_SHIFT)) & CACHE_CCR_SETMANPOW_MASK) + +#define CACHE_CCR_POWREQ_SHIFT (2) +#define CACHE_CCR_POWREQ_MASK (0x01U << CACHE_CCR_POWREQ_SHIFT) +#define CACHE_CCR_POWREQ(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CCR_POWREQ_SHIFT)) & CACHE_CCR_POWREQ_MASK) + +#define CACHE_CCR_INVREQ_SHIFT (1) +#define CACHE_CCR_INVREQ_MASK (0x01U << CACHE_CCR_INVREQ_SHIFT) +#define CACHE_CCR_INVREQ(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CCR_INVREQ_SHIFT)) & CACHE_CCR_INVREQ_MASK) + +#define CACHE_CCR_EN_SHIFT (0) +#define CACHE_CCR_EN_MASK (0x01U << CACHE_CCR_EN_SHIFT) +#define CACHE_CCR_EN(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CCR_EN_SHIFT)) & CACHE_CCR_EN_MASK) + +/*! + * @brief CACHE_SR Register Bit Definition + */ + +#define CACHE_SR_POWSTAT_SHIFT (4) +#define CACHE_SR_POWSTAT_MASK (0x01U << CACHE_SR_POWSTAT_SHIFT) +#define CACHE_SR_POWSTAT(x) (((uint32_t)(((uint32_t)(x)) << CACHE_SR_POWSTAT_SHIFT)) & CACHE_SR_POWSTAT_MASK) + +#define CACHE_SR_INVSTAT_SHIFT (2) +#define CACHE_SR_INVSTAT_MASK (0x01U << CACHE_SR_INVSTAT_SHIFT) +#define CACHE_SR_INVSTAT(x) (((uint32_t)(((uint32_t)(x)) << CACHE_SR_INVSTAT_SHIFT)) & CACHE_SR_INVSTAT_MASK) + +#define CACHE_SR_CS_SHIFT (0) +#define CACHE_SR_CS_MASK (0x3U << CACHE_SR_CS_SHIFT) +#define CACHE_SR_CS(x) (((uint32_t)(((uint32_t)(x)) << CACHE_SR_CS_SHIFT)) & CACHE_SR_CS_MASK) + +/*! + * @brief CACHE_IMR Register Bit Definition + */ + +#define CACHE_IMR_MANINVERR_SHIFT (1) +#define CACHE_IMR_MANINVERR_MASK (0x01U << CACHE_IMR_MANINVERR_SHIFT) +#define CACHE_IMR_MANINVERR(x) (((uint32_t)(((uint32_t)(x)) << CACHE_IMR_MANINVERR_SHIFT)) & CACHE_IMR_MANINVERR_MASK) + +#define CACHE_IMR_POWERR_SHIFT (0) +#define CACHE_IMR_POWERR_MASK (0x01U << CACHE_IMR_POWERR_SHIFT) +#define CACHE_IMR_POWERR(x) (((uint32_t)(((uint32_t)(x)) << CACHE_IMR_POWERR_SHIFT)) & CACHE_IMR_POWERR_MASK) + +/*! + * @brief CACHE_ISR Register Bit Definition + */ + +#define CACHE_ISR_MANINVERR_SHIFT (1) +#define CACHE_ISR_MANINVERR_MASK (0x01U << CACHE_ISR_MANINVERR_SHIFT) +#define CACHE_ISR_MANINVERR(x) (((uint32_t)(((uint32_t)(x)) << CACHE_ISR_MANINVERR_SHIFT)) & CACHE_ISR_MANINVERR_MASK) + +#define CACHE_ISR_POWERR_SHIFT (0) +#define CACHE_ISR_POWERR_MASK (0x01U << CACHE_ISR_POWERR_SHIFT) +#define CACHE_ISR_POWERR(x) (((uint32_t)(((uint32_t)(x)) << CACHE_ISR_POWERR_SHIFT)) & CACHE_ISR_POWERR_MASK) + +/*! + * @brief CACHE_CSHR Register Bit Definition + */ + +#define CACHE_CSHR_CSHR_SHIFT (0) +#define CACHE_CSHR_CSHR_MASK (0xFFFFFFFFU << CACHE_CSHR_CSHR_SHIFT) +#define CACHE_CSHR_CSHR(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CSHR_CSHR_SHIFT)) & CACHE_CSHR_CSHR_MASK) + +/*! + * @brief CACHE_CSMR Register Bit Definition + */ + +#define CACHE_CSMR_CSMR_SHIFT (0) +#define CACHE_CSMR_CSMR_MASK (0xFFFFFFFFU << CACHE_CSMR_CSMR_SHIFT) +#define CACHE_CSMR_CSMR(x) (((uint32_t)(((uint32_t)(x)) << CACHE_CSMR_CSMR_SHIFT)) & CACHE_CSMR_CSMR_MASK) + +/*! + * @} + */ /* end of group CACHE_Register_Masks */ +/****************************************************************************** + * CACHE Instance +******************************************************************************/ +#define CACHE ((CACHE_Type*)CACHE_BASE) + +/*! + * @} + */ /* end of group CACHE_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup PWR_Peripheral_Access_Layer PWR Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * PWR Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR1; ///< Power control register 1 offset: 0x00 + __IO uint32_t CSR; ///< Power control status register offset: 0x04 + __IO uint32_t CR2; ///< Power control register 2 offset: 0x08 + __IO uint32_t CR3; ///< Power Control Register 3 offset: 0x0C + __IO uint32_t CR4; ///< Power Control Register 4 offset: 0x10 + __IO uint32_t CR5; ///< Power Control Register 5 offset: 0x14 + __IO uint32_t CR6; ///< Power Control Register 6 offset: 0x18 + __IO uint32_t SR; ///< Power status register offset: 0x1C + __IO uint32_t SCR; ///< Power Configuration Register offset: 0x18 + __IO uint32_t Reserved2[3]; ///< Reserved + __IO uint32_t CFGR; ///< Power Configuration Register offset: 0x28 +} PWR_Type; + +/******************************************************************************* + * PWR Type + ******************************************************************************/ + +/*! + * @addtogroup PWR_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief PWR_CR1 Register Bit Definition + */ + +#define PWR_CR1_VOS_SHIFT (14) +#define PWR_CR1_VOS_MASK (0x3U << PWR_CR1_VOS_SHIFT) +#define PWR_CR1_VOS(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR1_VOS_SHIFT)) & PWR_CR1_VOS_MASK) + +#define PWR_CR1_LPR_SHIFT (13) +#define PWR_CR1_LPR_MASK (0x01U << PWR_CR1_LPR_SHIFT) +#define PWR_CR1_LPR(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR1_LPR_SHIFT)) & PWR_CR1_LPR_MASK) + +#define PWR_CR1_CSBF_SHIFT (3) +#define PWR_CR1_CSBF_MASK (0x01U << PWR_CR1_CSBF_SHIFT) +#define PWR_CR1_CSBF(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR1_CSBF_SHIFT)) & PWR_CR1_CSBF_MASK) + +#define PWR_CR1_PDDS_SHIFT (1) +#define PWR_CR1_PDDS_MASK (0x01U << PWR_CR1_PDDS_SHIFT) +#define PWR_CR1_PDDS(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR1_PDDS_SHIFT)) & PWR_CR1_PDDS_MASK) + +#define PWR_CR1_LPDS_SHIFT (0) +#define PWR_CR1_LPDS_MASK (0x01U << PWR_CR1_LPDS_SHIFT) +#define PWR_CR1_LPDS(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR1_LPDS_SHIFT)) & PWR_CR1_LPDS_MASK) + +/*! + * @brief PWR_CSR Register Bit Definition + */ + +#define PWR_CSR_VOSRDY_SHIFT (14) +#define PWR_CSR_VOSRDY_MASK (0x01U << PWR_CSR_VOSRDY_SHIFT) +#define PWR_CSR_VOSRDY(x) (((uint32_t)(((uint32_t)(x)) << PWR_CSR_VOSRDY_SHIFT)) & PWR_CSR_VOSRDY_MASK) + +#define PWR_CSR_SBF_SHIFT (1) +#define PWR_CSR_SBF_MASK (0x01U << PWR_CSR_SBF_SHIFT) +#define PWR_CSR_SBF(x) (((uint32_t)(((uint32_t)(x)) << PWR_CSR_SBF_SHIFT)) & PWR_CSR_SBF_MASK) + +/*! + * @brief PWR_CR2 Register Bit Definition + */ + +#define PWR_CR2_ENWU_SHIFT (15) +#define PWR_CR2_ENWU_MASK (0x01U << PWR_CR2_ENWU_SHIFT) +#define PWR_CR2_ENWU(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR2_ENWU_SHIFT)) & PWR_CR2_ENWU_MASK) + +#define PWR_CR2_EWUP_SHIFT (0) +#define PWR_CR2_EWUP_MASK (0x3FU << PWR_CR2_EWUP_SHIFT) +#define PWR_CR2_EWUP(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR2_EWUP_SHIFT)) & PWR_CR2_EWUP_MASK) + +/*! + * @brief PWR_CR3 Register Bit Definition + */ + +#define PWR_CR3_WP_SHIFT (0) +#define PWR_CR3_WP_MASK (0x3FU << PWR_CR3_WP_SHIFT) +#define PWR_CR3_WP(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR3_WP_SHIFT)) & PWR_CR3_WP_MASK) + +/*! + * @brief PWR_CR4 Register Bit Definition + */ + +#define PWR_CR4_FILTCNT0_SHIFT (8) +#define PWR_CR4_FILTCNT0_MASK (0xFFU << PWR_CR4_FILTCNT0_SHIFT) +#define PWR_CR4_FILTCNT0(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR4_FILTCNT0_SHIFT)) & PWR_CR4_FILTCNT0_MASK) + +#define PWR_CR4_FILTF0_SHIFT (4) +#define PWR_CR4_FILTF0_MASK (0x01U << PWR_CR4_FILTF0_SHIFT) +#define PWR_CR4_FILTF0(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR4_FILTF0_SHIFT)) & PWR_CR4_FILTF0_MASK) + +#define PWR_CR4_FILTE0_SHIFT (2) +#define PWR_CR4_FILTE0_MASK (0x3U << PWR_CR4_FILTE0_SHIFT) +#define PWR_CR4_FILTE0(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR4_FILTE0_SHIFT)) & PWR_CR4_FILTE0_MASK) + +#define PWR_CR4_FILTSEL0_SHIFT (0) +#define PWR_CR4_FILTSEL0_MASK (0x3U << PWR_CR4_FILTSEL0_SHIFT) +#define PWR_CR4_FILTSEL0(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR4_FILTSEL0_SHIFT)) & PWR_CR4_FILTSEL0_MASK) + +/*! + * @brief PWR_CR5 Register Bit Definition + */ + +#define PWR_CR5_FILTCNT1_SHIFT (8) +#define PWR_CR5_FILTCNT1_MASK (0xFFU << PWR_CR5_FILTCNT1_SHIFT) +#define PWR_CR5_FILTCNT1(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR5_FILTCNT1_SHIFT)) & PWR_CR5_FILTCNT1_MASK) + +#define PWR_CR5_FILTF1_SHIFT (4) +#define PWR_CR5_FILTF1_MASK (0x01U << PWR_CR5_FILTF1_SHIFT) +#define PWR_CR5_FILTF1(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR5_FILTF1_SHIFT)) & PWR_CR5_FILTF1_MASK) + +#define PWR_CR5_FILTE1_SHIFT (2) +#define PWR_CR5_FILTE1_MASK (0x3U << PWR_CR5_FILTE1_SHIFT) +#define PWR_CR5_FILTE1(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR5_FILTE1_SHIFT)) & PWR_CR5_FILTE1_MASK) + +#define PWR_CR5_FILTSEL1_SHIFT (0) +#define PWR_CR5_FILTSEL1_MASK (0x3U << PWR_CR5_FILTSEL1_SHIFT) +#define PWR_CR5_FILTSEL1(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR5_FILTSEL1_SHIFT)) & PWR_CR5_FILTSEL1_MASK) + +/*! + * @brief PWR_CR6 Register Bit Definition + */ + +#define PWR_CR6_STDBY_FS_WK_SHIFT (0) +#define PWR_CR6_STDBY_FS_WK_MASK (0x7U << PWR_CR6_STDBY_FS_WK_SHIFT) +#define PWR_CR6_STDBY_FS_WK(x) (((uint32_t)(((uint32_t)(x)) << PWR_CR6_STDBY_FS_WK_SHIFT)) & PWR_CR6_STDBY_FS_WK_MASK) + +/*! + * @brief PWR_SR Register Bit Definition + */ + +#define PWR_SR_WUF_SHIFT (0) +#define PWR_SR_WUF_MASK (0x3FU << PWR_SR_WUF_SHIFT) +#define PWR_SR_WUF(x) (((uint32_t)(((uint32_t)(x)) << PWR_SR_WUF_SHIFT)) & PWR_SR_WUF_MASK) + +/*! + * @brief PWR_SCR Register Bit Definition + */ + +#define PWR_SCR_CWUF_SHIFT (0) +#define PWR_SCR_CWUF_MASK (0x3FU << PWR_SCR_CWUF_SHIFT) +#define PWR_SCR_CWUF(x) (((uint32_t)(((uint32_t)(x)) << PWR_SCR_CWUF_SHIFT)) & PWR_SCR_CWUF_MASK) + +/*! + * @brief PWR_CFGR Register Bit Definition + */ + +#define PWR_CFGR_LSICAL_SHIFT (5) +#define PWR_CFGR_LSICAL_MASK (0x1FU << PWR_CFGR_LSICAL_SHIFT) +#define PWR_CFGR_LSICAL(x) (((uint32_t)(((uint32_t)(x)) << PWR_CFGR_LSICAL_SHIFT)) & PWR_CFGR_LSICAL_MASK) + +#define PWR_CFGR_LSICALSEL_SHIFT (0) +#define PWR_CFGR_LSICALSEL_MASK (0x1FU << PWR_CFGR_LSICALSEL_SHIFT) +#define PWR_CFGR_LSICALSEL(x) (((uint32_t)(((uint32_t)(x)) << PWR_CFGR_LSICALSEL_SHIFT)) & PWR_CFGR_LSICALSEL_MASK) + +/*! + * @} + */ /* end of group PWR_Register_Masks */ +/****************************************************************************** + * PWR Instance +******************************************************************************/ +#define PWR ((PWR_Type*)PWR_BASE) + +/*! + * @} + */ /* end of group PWR_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup RCC_Peripheral_Access_Layer RCC Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * RCC Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR; ///< Clock control register offset: 0x00 + __IO uint32_t CFGR; ///< Clock configuration register offset: 0x04 + __IO uint32_t CIR; ///< Clock interrupt register offset: 0x08 + __IO uint32_t AHB3RSTR; ///< AHB3 peripheral reset register offset: 0x0C + __IO uint32_t AHB2RSTR; ///< AHB2 peripheral reset register offset: 0x10 + __IO uint32_t AHB1RSTR; ///< AHB1 peripheral reset register offset: 0x14 + __IO uint32_t APB2RSTR; ///< APB2 peripheral reset register offset: 0x18 + __IO uint32_t APB1RSTR; ///< APB1 peripheral reset register offset: 0x1C + __IO uint32_t AHB3ENR; ///< AHB3 peripheral clock enable register offset: 0x20 + __IO uint32_t AHB2ENR; ///< AHB2 peripheral clock enable register offset: 0x24 + __IO uint32_t AHB1ENR; ///< AHB1 peripheral clock enable register offset: 0x28 + __IO uint32_t APB2ENR; ///< APB2 peripheral clock enable register offset: 0x2C + __IO uint32_t APB1ENR; ///< APB1 peripheral clock enable register offset: 0x30 + __IO uint32_t BDCR; ///< Backup domain control register offset: 0x34 + __IO uint32_t CSR; ///< Control status register offset: 0x38 + __IO uint32_t SYSCFG; ///< System Configuration Register offset: 0x3C + __IO uint32_t CFGR2; ///< Clock configuration register 2 offset: 0x40 + __IO uint32_t ICSCR; ///< Internal clock source calibration register offset: 0x44 + __IO uint32_t PLLCFGR; ///< PLL configuration register offset: 0x48 + __IO uint32_t Reserved3[13]; ///< Reserved + __IO uint32_t HSIDLY; ///< HSI delay register offset: 0x80 + __IO uint32_t HSEDLY; ///< HSE delay register offset: 0x84 + __IO uint32_t PLLDLY; ///< PLL delay register offset: 0x88 +} RCC_Type; + +/******************************************************************************* + * RCC Type + ******************************************************************************/ + +/*! + * @addtogroup RCC_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief RCC_CR Register Bit Definition + */ + +#define RCC_CR_PLLRDY_SHIFT (25) +#define RCC_CR_PLLRDY_MASK (0x01U << RCC_CR_PLLRDY_SHIFT) +#define RCC_CR_PLLRDY(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_PLLRDY_SHIFT)) & RCC_CR_PLLRDY_MASK) + +#define RCC_CR_PLLON_SHIFT (24) +#define RCC_CR_PLLON_MASK (0x01U << RCC_CR_PLLON_SHIFT) +#define RCC_CR_PLLON(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_PLLON_SHIFT)) & RCC_CR_PLLON_MASK) + +#define RCC_CR_CSSON_SHIFT (19) +#define RCC_CR_CSSON_MASK (0x01U << RCC_CR_CSSON_SHIFT) +#define RCC_CR_CSSON(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_CSSON_SHIFT)) & RCC_CR_CSSON_MASK) + +#define RCC_CR_HSEBYP_SHIFT (18) +#define RCC_CR_HSEBYP_MASK (0x01U << RCC_CR_HSEBYP_SHIFT) +#define RCC_CR_HSEBYP(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_HSEBYP_SHIFT)) & RCC_CR_HSEBYP_MASK) + +#define RCC_CR_HSERDY_SHIFT (17) +#define RCC_CR_HSERDY_MASK (0x01U << RCC_CR_HSERDY_SHIFT) +#define RCC_CR_HSERDY(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_HSERDY_SHIFT)) & RCC_CR_HSERDY_MASK) + +#define RCC_CR_HSEON_SHIFT (16) +#define RCC_CR_HSEON_MASK (0x01U << RCC_CR_HSEON_SHIFT) +#define RCC_CR_HSEON(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_HSEON_SHIFT)) & RCC_CR_HSEON_MASK) + +#define RCC_CR_HSIDIV_SHIFT (11) +#define RCC_CR_HSIDIV_MASK (0x7U << RCC_CR_HSIDIV_SHIFT) +#define RCC_CR_HSIDIV(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_HSIDIV_SHIFT)) & RCC_CR_HSIDIV_MASK) + +#define RCC_CR_HSIRDY_SHIFT (1) +#define RCC_CR_HSIRDY_MASK (0x01U << RCC_CR_HSIRDY_SHIFT) +#define RCC_CR_HSIRDY(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_HSIRDY_SHIFT)) & RCC_CR_HSIRDY_MASK) + +#define RCC_CR_HSION_SHIFT (0) +#define RCC_CR_HSION_MASK (0x01U << RCC_CR_HSION_SHIFT) +#define RCC_CR_HSION(x) (((uint32_t)(((uint32_t)(x)) << RCC_CR_HSION_SHIFT)) & RCC_CR_HSION_MASK) + +/*! + * @brief RCC_CFGR Register Bit Definition + */ + +#define RCC_CFGR_MCO_SHIFT (24) +#define RCC_CFGR_MCO_MASK (0x7U << RCC_CFGR_MCO_SHIFT) +#define RCC_CFGR_MCO(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR_MCO_SHIFT)) & RCC_CFGR_MCO_MASK) + +#define RCC_CFGR_USBPRE_SHIFT (22) +#define RCC_CFGR_USBPRE_MASK (0x3U << RCC_CFGR_USBPRE_SHIFT) +#define RCC_CFGR_USBPRE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR_USBPRE_SHIFT)) & RCC_CFGR_USBPRE_MASK) + +#define RCC_CFGR_PPRE2_SHIFT (11) +#define RCC_CFGR_PPRE2_MASK (0x7U << RCC_CFGR_PPRE2_SHIFT) +#define RCC_CFGR_PPRE2(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR_PPRE2_SHIFT)) & RCC_CFGR_PPRE2_MASK) + +#define RCC_CFGR_PPRE1_SHIFT (8) +#define RCC_CFGR_PPRE1_MASK (0x7U << RCC_CFGR_PPRE1_SHIFT) +#define RCC_CFGR_PPRE1(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR_PPRE1_SHIFT)) & RCC_CFGR_PPRE1_MASK) + +#define RCC_CFGR_HPRE_SHIFT (4) +#define RCC_CFGR_HPRE_MASK (0xFU << RCC_CFGR_HPRE_SHIFT) +#define RCC_CFGR_HPRE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR_HPRE_SHIFT)) & RCC_CFGR_HPRE_MASK) + +#define RCC_CFGR_SWS_SHIFT (2) +#define RCC_CFGR_SWS_MASK (0x3U << RCC_CFGR_SWS_SHIFT) +#define RCC_CFGR_SWS(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR_SWS_SHIFT)) & RCC_CFGR_SWS_MASK) + +#define RCC_CFGR_SW_SHIFT (0) +#define RCC_CFGR_SW_MASK (0x3U << RCC_CFGR_SW_SHIFT) +#define RCC_CFGR_SW(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR_SW_SHIFT)) & RCC_CFGR_SW_MASK) + +/*! + * @brief RCC_CIR Register Bit Definition + */ + +#define RCC_CIR_CSSC_SHIFT (23) +#define RCC_CIR_CSSC_MASK (0x01U << RCC_CIR_CSSC_SHIFT) +#define RCC_CIR_CSSC(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_CSSC_SHIFT)) & RCC_CIR_CSSC_MASK) + +#define RCC_CIR_PLLRDYC_SHIFT (20) +#define RCC_CIR_PLLRDYC_MASK (0x01U << RCC_CIR_PLLRDYC_SHIFT) +#define RCC_CIR_PLLRDYC(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_PLLRDYC_SHIFT)) & RCC_CIR_PLLRDYC_MASK) + +#define RCC_CIR_HSERDYC_SHIFT (19) +#define RCC_CIR_HSERDYC_MASK (0x01U << RCC_CIR_HSERDYC_SHIFT) +#define RCC_CIR_HSERDYC(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_HSERDYC_SHIFT)) & RCC_CIR_HSERDYC_MASK) + +#define RCC_CIR_HSIRDYC_SHIFT (18) +#define RCC_CIR_HSIRDYC_MASK (0x01U << RCC_CIR_HSIRDYC_SHIFT) +#define RCC_CIR_HSIRDYC(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_HSIRDYC_SHIFT)) & RCC_CIR_HSIRDYC_MASK) + +#define RCC_CIR_LSERDYC_SHIFT (17) +#define RCC_CIR_LSERDYC_MASK (0x01U << RCC_CIR_LSERDYC_SHIFT) +#define RCC_CIR_LSERDYC(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_LSERDYC_SHIFT)) & RCC_CIR_LSERDYC_MASK) + +#define RCC_CIR_LSIRDYC_SHIFT (16) +#define RCC_CIR_LSIRDYC_MASK (0x01U << RCC_CIR_LSIRDYC_SHIFT) +#define RCC_CIR_LSIRDYC(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_LSIRDYC_SHIFT)) & RCC_CIR_LSIRDYC_MASK) + +#define RCC_CIR_PLLRDYIE_SHIFT (12) +#define RCC_CIR_PLLRDYIE_MASK (0x01U << RCC_CIR_PLLRDYIE_SHIFT) +#define RCC_CIR_PLLRDYIE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_PLLRDYIE_SHIFT)) & RCC_CIR_PLLRDYIE_MASK) + +#define RCC_CIR_HSERDYIE_SHIFT (11) +#define RCC_CIR_HSERDYIE_MASK (0x01U << RCC_CIR_HSERDYIE_SHIFT) +#define RCC_CIR_HSERDYIE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_HSERDYIE_SHIFT)) & RCC_CIR_HSERDYIE_MASK) + +#define RCC_CIR_HSIRDYIE_SHIFT (10) +#define RCC_CIR_HSIRDYIE_MASK (0x01U << RCC_CIR_HSIRDYIE_SHIFT) +#define RCC_CIR_HSIRDYIE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_HSIRDYIE_SHIFT)) & RCC_CIR_HSIRDYIE_MASK) + +#define RCC_CIR_LSERDYIE_SHIFT (9) +#define RCC_CIR_LSERDYIE_MASK (0x01U << RCC_CIR_LSERDYIE_SHIFT) +#define RCC_CIR_LSERDYIE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_LSERDYIE_SHIFT)) & RCC_CIR_LSERDYIE_MASK) + +#define RCC_CIR_LSIRDYIE_SHIFT (8) +#define RCC_CIR_LSIRDYIE_MASK (0x01U << RCC_CIR_LSIRDYIE_SHIFT) +#define RCC_CIR_LSIRDYIE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_LSIRDYIE_SHIFT)) & RCC_CIR_LSIRDYIE_MASK) + +#define RCC_CIR_CSSF_SHIFT (7) +#define RCC_CIR_CSSF_MASK (0x01U << RCC_CIR_CSSF_SHIFT) +#define RCC_CIR_CSSF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_CSSF_SHIFT)) & RCC_CIR_CSSF_MASK) + +#define RCC_CIR_PLLRDYF_SHIFT (4) +#define RCC_CIR_PLLRDYF_MASK (0x01U << RCC_CIR_PLLRDYF_SHIFT) +#define RCC_CIR_PLLRDYF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_PLLRDYF_SHIFT)) & RCC_CIR_PLLRDYF_MASK) + +#define RCC_CIR_HSERDYF_SHIFT (3) +#define RCC_CIR_HSERDYF_MASK (0x01U << RCC_CIR_HSERDYF_SHIFT) +#define RCC_CIR_HSERDYF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_HSERDYF_SHIFT)) & RCC_CIR_HSERDYF_MASK) + +#define RCC_CIR_HSIRDYF_SHIFT (2) +#define RCC_CIR_HSIRDYF_MASK (0x01U << RCC_CIR_HSIRDYF_SHIFT) +#define RCC_CIR_HSIRDYF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_HSIRDYF_SHIFT)) & RCC_CIR_HSIRDYF_MASK) + +#define RCC_CIR_LSERDYF_SHIFT (1) +#define RCC_CIR_LSERDYF_MASK (0x01U << RCC_CIR_LSERDYF_SHIFT) +#define RCC_CIR_LSERDYF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_LSERDYF_SHIFT)) & RCC_CIR_LSERDYF_MASK) + +#define RCC_CIR_LSIRDYF_SHIFT (0) +#define RCC_CIR_LSIRDYF_MASK (0x01U << RCC_CIR_LSIRDYF_SHIFT) +#define RCC_CIR_LSIRDYF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CIR_LSIRDYF_SHIFT)) & RCC_CIR_LSIRDYF_MASK) + +/*! + * @brief RCC_AHB3RSTR Register Bit Definition + */ + +#define RCC_AHB3RSTR_FSMC_SHIFT (0) +#define RCC_AHB3RSTR_FSMC_MASK (0x01U << RCC_AHB3RSTR_FSMC_SHIFT) +#define RCC_AHB3RSTR_FSMC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB3RSTR_FSMC_SHIFT)) & RCC_AHB3RSTR_FSMC_MASK) + +/*! + * @brief RCC_AHB2RSTR Register Bit Definition + */ + +#define RCC_AHB2RSTR_USBOTGFS_SHIFT (7) +#define RCC_AHB2RSTR_USBOTGFS_MASK (0x01U << RCC_AHB2RSTR_USBOTGFS_SHIFT) +#define RCC_AHB2RSTR_USBOTGFS(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB2RSTR_USBOTGFS_SHIFT)) & RCC_AHB2RSTR_USBOTGFS_MASK) + +/*! + * @brief RCC_AHB1RSTR Register Bit Definition + */ + +#define RCC_AHB1RSTR_ETHMAC_SHIFT (25) +#define RCC_AHB1RSTR_ETHMAC_MASK (0x01U << RCC_AHB1RSTR_ETHMAC_SHIFT) +#define RCC_AHB1RSTR_ETHMAC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_ETHMAC_SHIFT)) & RCC_AHB1RSTR_ETHMAC_MASK) + +#define RCC_AHB1RSTR_DMA2_SHIFT (22) +#define RCC_AHB1RSTR_DMA2_MASK (0x01U << RCC_AHB1RSTR_DMA2_SHIFT) +#define RCC_AHB1RSTR_DMA2(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_DMA2_SHIFT)) & RCC_AHB1RSTR_DMA2_MASK) + +#define RCC_AHB1RSTR_DMA1_SHIFT (21) +#define RCC_AHB1RSTR_DMA1_MASK (0x01U << RCC_AHB1RSTR_DMA1_SHIFT) +#define RCC_AHB1RSTR_DMA1(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_DMA1_SHIFT)) & RCC_AHB1RSTR_DMA1_MASK) + +#define RCC_AHB1RSTR_CRC_SHIFT (12) +#define RCC_AHB1RSTR_CRC_MASK (0x01U << RCC_AHB1RSTR_CRC_SHIFT) +#define RCC_AHB1RSTR_CRC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_CRC_SHIFT)) & RCC_AHB1RSTR_CRC_MASK) + +#define RCC_AHB1RSTR_SDIO_SHIFT (10) +#define RCC_AHB1RSTR_SDIO_MASK (0x01U << RCC_AHB1RSTR_SDIO_SHIFT) +#define RCC_AHB1RSTR_SDIO(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_SDIO_SHIFT)) & RCC_AHB1RSTR_SDIO_MASK) + +#define RCC_AHB1RSTR_GPIOH_SHIFT (7) +#define RCC_AHB1RSTR_GPIOH_MASK (0x01U << RCC_AHB1RSTR_GPIOH_SHIFT) +#define RCC_AHB1RSTR_GPIOH(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOH_SHIFT)) & RCC_AHB1RSTR_GPIOH_MASK) + +#define RCC_AHB1RSTR_GPIOG_SHIFT (6) +#define RCC_AHB1RSTR_GPIOG_MASK (0x01U << RCC_AHB1RSTR_GPIOG_SHIFT) +#define RCC_AHB1RSTR_GPIOG(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOG_SHIFT)) & RCC_AHB1RSTR_GPIOG_MASK) + +#define RCC_AHB1RSTR_GPIOF_SHIFT (5) +#define RCC_AHB1RSTR_GPIOF_MASK (0x01U << RCC_AHB1RSTR_GPIOF_SHIFT) +#define RCC_AHB1RSTR_GPIOF(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOF_SHIFT)) & RCC_AHB1RSTR_GPIOF_MASK) + +#define RCC_AHB1RSTR_GPIOE_SHIFT (4) +#define RCC_AHB1RSTR_GPIOE_MASK (0x01U << RCC_AHB1RSTR_GPIOE_SHIFT) +#define RCC_AHB1RSTR_GPIOE(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOE_SHIFT)) & RCC_AHB1RSTR_GPIOE_MASK) + +#define RCC_AHB1RSTR_GPIOD_SHIFT (3) +#define RCC_AHB1RSTR_GPIOD_MASK (0x01U << RCC_AHB1RSTR_GPIOD_SHIFT) +#define RCC_AHB1RSTR_GPIOD(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOD_SHIFT)) & RCC_AHB1RSTR_GPIOD_MASK) + +#define RCC_AHB1RSTR_GPIOC_SHIFT (2) +#define RCC_AHB1RSTR_GPIOC_MASK (0x01U << RCC_AHB1RSTR_GPIOC_SHIFT) +#define RCC_AHB1RSTR_GPIOC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOC_SHIFT)) & RCC_AHB1RSTR_GPIOC_MASK) + +#define RCC_AHB1RSTR_GPIOB_SHIFT (1) +#define RCC_AHB1RSTR_GPIOB_MASK (0x01U << RCC_AHB1RSTR_GPIOB_SHIFT) +#define RCC_AHB1RSTR_GPIOB(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOB_SHIFT)) & RCC_AHB1RSTR_GPIOB_MASK) + +#define RCC_AHB1RSTR_GPIOA_SHIFT (0) +#define RCC_AHB1RSTR_GPIOA_MASK (0x01U << RCC_AHB1RSTR_GPIOA_SHIFT) +#define RCC_AHB1RSTR_GPIOA(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1RSTR_GPIOA_SHIFT)) & RCC_AHB1RSTR_GPIOA_MASK) + +/*! + * @brief RCC_APB2RSTR Register Bit Definition + */ + +#define RCC_APB2RSTR_COMP_SHIFT (15) +#define RCC_APB2RSTR_COMP_MASK (0x01U << RCC_APB2RSTR_COMP_SHIFT) +#define RCC_APB2RSTR_COMP(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_COMP_SHIFT)) & RCC_APB2RSTR_COMP_MASK) + +#define RCC_APB2RSTR_SYSCFG_SHIFT (14) +#define RCC_APB2RSTR_SYSCFG_MASK (0x01U << RCC_APB2RSTR_SYSCFG_SHIFT) +#define RCC_APB2RSTR_SYSCFG(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_SYSCFG_SHIFT)) & RCC_APB2RSTR_SYSCFG_MASK) + +#define RCC_APB2RSTR_SPI1_SHIFT (12) +#define RCC_APB2RSTR_SPI1_MASK (0x01U << RCC_APB2RSTR_SPI1_SHIFT) +#define RCC_APB2RSTR_SPI1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_SPI1_SHIFT)) & RCC_APB2RSTR_SPI1_MASK) + +#define RCC_APB2RSTR_ADC3_SHIFT (10) +#define RCC_APB2RSTR_ADC3_MASK (0x01U << RCC_APB2RSTR_ADC3_SHIFT) +#define RCC_APB2RSTR_ADC3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_ADC3_SHIFT)) & RCC_APB2RSTR_ADC3_MASK) + +#define RCC_APB2RSTR_ADC2_SHIFT (9) +#define RCC_APB2RSTR_ADC2_MASK (0x01U << RCC_APB2RSTR_ADC2_SHIFT) +#define RCC_APB2RSTR_ADC2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_ADC2_SHIFT)) & RCC_APB2RSTR_ADC2_MASK) + +#define RCC_APB2RSTR_ADC1_SHIFT (8) +#define RCC_APB2RSTR_ADC1_MASK (0x01U << RCC_APB2RSTR_ADC1_SHIFT) +#define RCC_APB2RSTR_ADC1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_ADC1_SHIFT)) & RCC_APB2RSTR_ADC1_MASK) + +#define RCC_APB2RSTR_UART6_SHIFT (5) +#define RCC_APB2RSTR_UART6_MASK (0x01U << RCC_APB2RSTR_UART6_SHIFT) +#define RCC_APB2RSTR_UART6(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_UART6_SHIFT)) & RCC_APB2RSTR_UART6_MASK) + +#define RCC_APB2RSTR_UART1_SHIFT (4) +#define RCC_APB2RSTR_UART1_MASK (0x01U << RCC_APB2RSTR_UART1_SHIFT) +#define RCC_APB2RSTR_UART1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_UART1_SHIFT)) & RCC_APB2RSTR_UART1_MASK) + +#define RCC_APB2RSTR_TIM8_SHIFT (1) +#define RCC_APB2RSTR_TIM8_MASK (0x01U << RCC_APB2RSTR_TIM8_SHIFT) +#define RCC_APB2RSTR_TIM8(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_TIM8_SHIFT)) & RCC_APB2RSTR_TIM8_MASK) + +#define RCC_APB2RSTR_TIM1_SHIFT (0) +#define RCC_APB2RSTR_TIM1_MASK (0x01U << RCC_APB2RSTR_TIM1_SHIFT) +#define RCC_APB2RSTR_TIM1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2RSTR_TIM1_SHIFT)) & RCC_APB2RSTR_TIM1_MASK) + +/*! + * @brief RCC_APB1RSTR Register Bit Definition + */ + +#define RCC_APB1RSTR_UART8_SHIFT (31) +#define RCC_APB1RSTR_UART8_MASK (0x01U << RCC_APB1RSTR_UART8_SHIFT) +#define RCC_APB1RSTR_UART8(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_UART8_SHIFT)) & RCC_APB1RSTR_UART8_MASK) + +#define RCC_APB1RSTR_UART7_SHIFT (30) +#define RCC_APB1RSTR_UART7_MASK (0x01U << RCC_APB1RSTR_UART7_SHIFT) +#define RCC_APB1RSTR_UART7(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_UART7_SHIFT)) & RCC_APB1RSTR_UART7_MASK) + +#define RCC_APB1RSTR_DAC_SHIFT (29) +#define RCC_APB1RSTR_DAC_MASK (0x01U << RCC_APB1RSTR_DAC_SHIFT) +#define RCC_APB1RSTR_DAC(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_DAC_SHIFT)) & RCC_APB1RSTR_DAC_MASK) + +#define RCC_APB1RSTR_PWR_SHIFT (28) +#define RCC_APB1RSTR_PWR_MASK (0x01U << RCC_APB1RSTR_PWR_SHIFT) +#define RCC_APB1RSTR_PWR(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_PWR_SHIFT)) & RCC_APB1RSTR_PWR_MASK) + +#define RCC_APB1RSTR_BKP_SHIFT (27) +#define RCC_APB1RSTR_BKP_MASK (0x01U << RCC_APB1RSTR_BKP_SHIFT) +#define RCC_APB1RSTR_BKP(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_BKP_SHIFT)) & RCC_APB1RSTR_BKP_MASK) + +#define RCC_APB1RSTR_CAN_SHIFT (25) +#define RCC_APB1RSTR_CAN_MASK (0x01U << RCC_APB1RSTR_CAN_SHIFT) +#define RCC_APB1RSTR_CAN(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_CAN_SHIFT)) & RCC_APB1RSTR_CAN_MASK) + +#define RCC_APB1RSTR_CRS_SHIFT (24) +#define RCC_APB1RSTR_CRS_MASK (0x01U << RCC_APB1RSTR_CRS_SHIFT) +#define RCC_APB1RSTR_CRS(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_CRS_SHIFT)) & RCC_APB1RSTR_CRS_MASK) + +#define RCC_APB1RSTR_I2C2_SHIFT (22) +#define RCC_APB1RSTR_I2C2_MASK (0x01U << RCC_APB1RSTR_I2C2_SHIFT) +#define RCC_APB1RSTR_I2C2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_I2C2_SHIFT)) & RCC_APB1RSTR_I2C2_MASK) + +#define RCC_APB1RSTR_I2C1_SHIFT (21) +#define RCC_APB1RSTR_I2C1_MASK (0x01U << RCC_APB1RSTR_I2C1_SHIFT) +#define RCC_APB1RSTR_I2C1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_I2C1_SHIFT)) & RCC_APB1RSTR_I2C1_MASK) + +#define RCC_APB1RSTR_UART5_SHIFT (20) +#define RCC_APB1RSTR_UART5_MASK (0x01U << RCC_APB1RSTR_UART5_SHIFT) +#define RCC_APB1RSTR_UART5(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_UART5_SHIFT)) & RCC_APB1RSTR_UART5_MASK) + +#define RCC_APB1RSTR_UART4_SHIFT (19) +#define RCC_APB1RSTR_UART4_MASK (0x01U << RCC_APB1RSTR_UART4_SHIFT) +#define RCC_APB1RSTR_UART4(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_UART4_SHIFT)) & RCC_APB1RSTR_UART4_MASK) + +#define RCC_APB1RSTR_UART3_SHIFT (18) +#define RCC_APB1RSTR_UART3_MASK (0x01U << RCC_APB1RSTR_UART3_SHIFT) +#define RCC_APB1RSTR_UART3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_UART3_SHIFT)) & RCC_APB1RSTR_UART3_MASK) + +#define RCC_APB1RSTR_UART2_SHIFT (17) +#define RCC_APB1RSTR_UART2_MASK (0x01U << RCC_APB1RSTR_UART2_SHIFT) +#define RCC_APB1RSTR_UART2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_UART2_SHIFT)) & RCC_APB1RSTR_UART2_MASK) + +#define RCC_APB1RSTR_SPI3_SHIFT (15) +#define RCC_APB1RSTR_SPI3_MASK (0x01U << RCC_APB1RSTR_SPI3_SHIFT) +#define RCC_APB1RSTR_SPI3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_SPI3_SHIFT)) & RCC_APB1RSTR_SPI3_MASK) + +#define RCC_APB1RSTR_SPI2_SHIFT (14) +#define RCC_APB1RSTR_SPI2_MASK (0x01U << RCC_APB1RSTR_SPI2_SHIFT) +#define RCC_APB1RSTR_SPI2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_SPI2_SHIFT)) & RCC_APB1RSTR_SPI2_MASK) + +#define RCC_APB1RSTR_WWDG_SHIFT (11) +#define RCC_APB1RSTR_WWDG_MASK (0x01U << RCC_APB1RSTR_WWDG_SHIFT) +#define RCC_APB1RSTR_WWDG(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_WWDG_SHIFT)) & RCC_APB1RSTR_WWDG_MASK) + +#define RCC_APB1RSTR_TIM7_SHIFT (5) +#define RCC_APB1RSTR_TIM7_MASK (0x01U << RCC_APB1RSTR_TIM7_SHIFT) +#define RCC_APB1RSTR_TIM7(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_TIM7_SHIFT)) & RCC_APB1RSTR_TIM7_MASK) + +#define RCC_APB1RSTR_TIM6_SHIFT (4) +#define RCC_APB1RSTR_TIM6_MASK (0x01U << RCC_APB1RSTR_TIM6_SHIFT) +#define RCC_APB1RSTR_TIM6(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_TIM6_SHIFT)) & RCC_APB1RSTR_TIM6_MASK) + +#define RCC_APB1RSTR_TIM5_SHIFT (3) +#define RCC_APB1RSTR_TIM5_MASK (0x01U << RCC_APB1RSTR_TIM5_SHIFT) +#define RCC_APB1RSTR_TIM5(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_TIM5_SHIFT)) & RCC_APB1RSTR_TIM5_MASK) + +#define RCC_APB1RSTR_TIM4_SHIFT (2) +#define RCC_APB1RSTR_TIM4_MASK (0x01U << RCC_APB1RSTR_TIM4_SHIFT) +#define RCC_APB1RSTR_TIM4(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_TIM4_SHIFT)) & RCC_APB1RSTR_TIM4_MASK) + +#define RCC_APB1RSTR_TIM3_SHIFT (1) +#define RCC_APB1RSTR_TIM3_MASK (0x01U << RCC_APB1RSTR_TIM3_SHIFT) +#define RCC_APB1RSTR_TIM3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_TIM3_SHIFT)) & RCC_APB1RSTR_TIM3_MASK) + +#define RCC_APB1RSTR_TIM2_SHIFT (0) +#define RCC_APB1RSTR_TIM2_MASK (0x01U << RCC_APB1RSTR_TIM2_SHIFT) +#define RCC_APB1RSTR_TIM2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1RSTR_TIM2_SHIFT)) & RCC_APB1RSTR_TIM2_MASK) + +/*! + * @brief RCC_AHB3ENR Register Bit Definition + */ + +#define RCC_AHB3ENR_FSMC_SHIFT (0) +#define RCC_AHB3ENR_FSMC_MASK (0x01U << RCC_AHB3ENR_FSMC_SHIFT) +#define RCC_AHB3ENR_FSMC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB3ENR_FSMC_SHIFT)) & RCC_AHB3ENR_FSMC_MASK) + +/*! + * @brief RCC_AHB2ENR Register Bit Definition + */ + +#define RCC_AHB2ENR_USBOTGFS_SHIFT (7) +#define RCC_AHB2ENR_USBOTGFS_MASK (0x01U << RCC_AHB2ENR_USBOTGFS_SHIFT) +#define RCC_AHB2ENR_USBOTGFS(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB2ENR_USBOTGFS_SHIFT)) & RCC_AHB2ENR_USBOTGFS_MASK) + +/*! + * @brief RCC_AHB1ENR Register Bit Definition + */ + +#define RCC_AHB1ENR_ETHMAC_SHIFT (25) +#define RCC_AHB1ENR_ETHMAC_MASK (0x01U << RCC_AHB1ENR_ETHMAC_SHIFT) +#define RCC_AHB1ENR_ETHMAC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_ETHMAC_SHIFT)) & RCC_AHB1ENR_ETHMAC_MASK) + +#define RCC_AHB1ENR_DMA2_SHIFT (22) +#define RCC_AHB1ENR_DMA2_MASK (0x01U << RCC_AHB1ENR_DMA2_SHIFT) +#define RCC_AHB1ENR_DMA2(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_DMA2_SHIFT)) & RCC_AHB1ENR_DMA2_MASK) + +#define RCC_AHB1ENR_DMA1_SHIFT (21) +#define RCC_AHB1ENR_DMA1_MASK (0x01U << RCC_AHB1ENR_DMA1_SHIFT) +#define RCC_AHB1ENR_DMA1(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_DMA1_SHIFT)) & RCC_AHB1ENR_DMA1_MASK) + +#define RCC_AHB1ENR_SRAM_SHIFT (14) +#define RCC_AHB1ENR_SRAM_MASK (0x01U << RCC_AHB1ENR_SRAM_SHIFT) +#define RCC_AHB1ENR_SRAM(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_SRAM_SHIFT)) & RCC_AHB1ENR_SRAM_MASK) + +#define RCC_AHB1ENR_FLASH_SHIFT (13) +#define RCC_AHB1ENR_FLASH_MASK (0x01U << RCC_AHB1ENR_FLASH_SHIFT) +#define RCC_AHB1ENR_FLASH(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_FLASH_SHIFT)) & RCC_AHB1ENR_FLASH_MASK) + +#define RCC_AHB1ENR_CRC_SHIFT (12) +#define RCC_AHB1ENR_CRC_MASK (0x01U << RCC_AHB1ENR_CRC_SHIFT) +#define RCC_AHB1ENR_CRC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_CRC_SHIFT)) & RCC_AHB1ENR_CRC_MASK) + +#define RCC_AHB1ENR_SDIO_SHIFT (10) +#define RCC_AHB1ENR_SDIO_MASK (0x01U << RCC_AHB1ENR_SDIO_SHIFT) +#define RCC_AHB1ENR_SDIO(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_SDIO_SHIFT)) & RCC_AHB1ENR_SDIO_MASK) + +#define RCC_AHB1ENR_GPIOH_SHIFT (7) +#define RCC_AHB1ENR_GPIOH_MASK (0x01U << RCC_AHB1ENR_GPIOH_SHIFT) +#define RCC_AHB1ENR_GPIOH(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOH_SHIFT)) & RCC_AHB1ENR_GPIOH_MASK) + +#define RCC_AHB1ENR_GPIOG_SHIFT (6) +#define RCC_AHB1ENR_GPIOG_MASK (0x01U << RCC_AHB1ENR_GPIOG_SHIFT) +#define RCC_AHB1ENR_GPIOG(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOG_SHIFT)) & RCC_AHB1ENR_GPIOG_MASK) + +#define RCC_AHB1ENR_GPIOF_SHIFT (5) +#define RCC_AHB1ENR_GPIOF_MASK (0x01U << RCC_AHB1ENR_GPIOF_SHIFT) +#define RCC_AHB1ENR_GPIOF(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOF_SHIFT)) & RCC_AHB1ENR_GPIOF_MASK) + +#define RCC_AHB1ENR_GPIOE_SHIFT (4) +#define RCC_AHB1ENR_GPIOE_MASK (0x01U << RCC_AHB1ENR_GPIOE_SHIFT) +#define RCC_AHB1ENR_GPIOE(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOE_SHIFT)) & RCC_AHB1ENR_GPIOE_MASK) + +#define RCC_AHB1ENR_GPIOD_SHIFT (3) +#define RCC_AHB1ENR_GPIOD_MASK (0x01U << RCC_AHB1ENR_GPIOD_SHIFT) +#define RCC_AHB1ENR_GPIOD(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOD_SHIFT)) & RCC_AHB1ENR_GPIOD_MASK) + +#define RCC_AHB1ENR_GPIOC_SHIFT (2) +#define RCC_AHB1ENR_GPIOC_MASK (0x01U << RCC_AHB1ENR_GPIOC_SHIFT) +#define RCC_AHB1ENR_GPIOC(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOC_SHIFT)) & RCC_AHB1ENR_GPIOC_MASK) + +#define RCC_AHB1ENR_GPIOB_SHIFT (1) +#define RCC_AHB1ENR_GPIOB_MASK (0x01U << RCC_AHB1ENR_GPIOB_SHIFT) +#define RCC_AHB1ENR_GPIOB(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOB_SHIFT)) & RCC_AHB1ENR_GPIOB_MASK) + +#define RCC_AHB1ENR_GPIOA_SHIFT (0) +#define RCC_AHB1ENR_GPIOA_MASK (0x01U << RCC_AHB1ENR_GPIOA_SHIFT) +#define RCC_AHB1ENR_GPIOA(x) (((uint32_t)(((uint32_t)(x)) << RCC_AHB1ENR_GPIOA_SHIFT)) & RCC_AHB1ENR_GPIOA_MASK) + +/*! + * @brief RCC_APB2ENR Register Bit Definition + */ + +#define RCC_APB2ENR_COMP_SHIFT (15) +#define RCC_APB2ENR_COMP_MASK (0x01U << RCC_APB2ENR_COMP_SHIFT) +#define RCC_APB2ENR_COMP(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_COMP_SHIFT)) & RCC_APB2ENR_COMP_MASK) + +#define RCC_APB2ENR_SYSCFG_SHIFT (14) +#define RCC_APB2ENR_SYSCFG_MASK (0x01U << RCC_APB2ENR_SYSCFG_SHIFT) +#define RCC_APB2ENR_SYSCFG(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_SYSCFG_SHIFT)) & RCC_APB2ENR_SYSCFG_MASK) + +#define RCC_APB2ENR_SPI1_SHIFT (12) +#define RCC_APB2ENR_SPI1_MASK (0x01U << RCC_APB2ENR_SPI1_SHIFT) +#define RCC_APB2ENR_SPI1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_SPI1_SHIFT)) & RCC_APB2ENR_SPI1_MASK) + +#define RCC_APB2ENR_ADC3_SHIFT (10) +#define RCC_APB2ENR_ADC3_MASK (0x01U << RCC_APB2ENR_ADC3_SHIFT) +#define RCC_APB2ENR_ADC3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_ADC3_SHIFT)) & RCC_APB2ENR_ADC3_MASK) + +#define RCC_APB2ENR_ADC2_SHIFT (9) +#define RCC_APB2ENR_ADC2_MASK (0x01U << RCC_APB2ENR_ADC2_SHIFT) +#define RCC_APB2ENR_ADC2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_ADC2_SHIFT)) & RCC_APB2ENR_ADC2_MASK) + +#define RCC_APB2ENR_ADC1_SHIFT (8) +#define RCC_APB2ENR_ADC1_MASK (0x01U << RCC_APB2ENR_ADC1_SHIFT) +#define RCC_APB2ENR_ADC1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_ADC1_SHIFT)) & RCC_APB2ENR_ADC1_MASK) + +#define RCC_APB2ENR_UART6_SHIFT (5) +#define RCC_APB2ENR_UART6_MASK (0x01U << RCC_APB2ENR_UART6_SHIFT) +#define RCC_APB2ENR_UART6(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_UART6_SHIFT)) & RCC_APB2ENR_UART6_MASK) + +#define RCC_APB2ENR_UART1_SHIFT (4) +#define RCC_APB2ENR_UART1_MASK (0x01U << RCC_APB2ENR_UART1_SHIFT) +#define RCC_APB2ENR_UART1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_UART1_SHIFT)) & RCC_APB2ENR_UART1_MASK) + +#define RCC_APB2ENR_TIM8_SHIFT (1) +#define RCC_APB2ENR_TIM8_MASK (0x01U << RCC_APB2ENR_TIM8_SHIFT) +#define RCC_APB2ENR_TIM8(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_TIM8_SHIFT)) & RCC_APB2ENR_TIM8_MASK) + +#define RCC_APB2ENR_TIM1_SHIFT (0) +#define RCC_APB2ENR_TIM1_MASK (0x01U << RCC_APB2ENR_TIM1_SHIFT) +#define RCC_APB2ENR_TIM1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB2ENR_TIM1_SHIFT)) & RCC_APB2ENR_TIM1_MASK) + +/*! + * @brief RCC_APB1ENR Register Bit Definition + */ + +#define RCC_APB1ENR_UART8_SHIFT (31) +#define RCC_APB1ENR_UART8_MASK (0x01U << RCC_APB1ENR_UART8_SHIFT) +#define RCC_APB1ENR_UART8(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_UART8_SHIFT)) & RCC_APB1ENR_UART8_MASK) + +#define RCC_APB1ENR_UART7_SHIFT (30) +#define RCC_APB1ENR_UART7_MASK (0x01U << RCC_APB1ENR_UART7_SHIFT) +#define RCC_APB1ENR_UART7(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_UART7_SHIFT)) & RCC_APB1ENR_UART7_MASK) + +#define RCC_APB1ENR_DAC_SHIFT (29) +#define RCC_APB1ENR_DAC_MASK (0x01U << RCC_APB1ENR_DAC_SHIFT) +#define RCC_APB1ENR_DAC(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_DAC_SHIFT)) & RCC_APB1ENR_DAC_MASK) + +#define RCC_APB1ENR_PWR_SHIFT (28) +#define RCC_APB1ENR_PWR_MASK (0x01U << RCC_APB1ENR_PWR_SHIFT) +#define RCC_APB1ENR_PWR(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_PWR_SHIFT)) & RCC_APB1ENR_PWR_MASK) + +#define RCC_APB1ENR_BKP_SHIFT (27) +#define RCC_APB1ENR_BKP_MASK (0x01U << RCC_APB1ENR_BKP_SHIFT) +#define RCC_APB1ENR_BKP(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_BKP_SHIFT)) & RCC_APB1ENR_BKP_MASK) + +#define RCC_APB1ENR_CAN_SHIFT (25) +#define RCC_APB1ENR_CAN_MASK (0x01U << RCC_APB1ENR_CAN_SHIFT) +#define RCC_APB1ENR_CAN(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_CAN_SHIFT)) & RCC_APB1ENR_CAN_MASK) + +#define RCC_APB1ENR_CRS_SHIFT (24) +#define RCC_APB1ENR_CRS_MASK (0x01U << RCC_APB1ENR_CRS_SHIFT) +#define RCC_APB1ENR_CRS(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_CRS_SHIFT)) & RCC_APB1ENR_CRS_MASK) + +#define RCC_APB1ENR_I2C2_SHIFT (22) +#define RCC_APB1ENR_I2C2_MASK (0x01U << RCC_APB1ENR_I2C2_SHIFT) +#define RCC_APB1ENR_I2C2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_I2C2_SHIFT)) & RCC_APB1ENR_I2C2_MASK) + +#define RCC_APB1ENR_I2C1_SHIFT (21) +#define RCC_APB1ENR_I2C1_MASK (0x01U << RCC_APB1ENR_I2C1_SHIFT) +#define RCC_APB1ENR_I2C1(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_I2C1_SHIFT)) & RCC_APB1ENR_I2C1_MASK) + +#define RCC_APB1ENR_UART5_SHIFT (20) +#define RCC_APB1ENR_UART5_MASK (0x01U << RCC_APB1ENR_UART5_SHIFT) +#define RCC_APB1ENR_UART5(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_UART5_SHIFT)) & RCC_APB1ENR_UART5_MASK) + +#define RCC_APB1ENR_UART4_SHIFT (19) +#define RCC_APB1ENR_UART4_MASK (0x01U << RCC_APB1ENR_UART4_SHIFT) +#define RCC_APB1ENR_UART4(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_UART4_SHIFT)) & RCC_APB1ENR_UART4_MASK) + +#define RCC_APB1ENR_UART3_SHIFT (18) +#define RCC_APB1ENR_UART3_MASK (0x01U << RCC_APB1ENR_UART3_SHIFT) +#define RCC_APB1ENR_UART3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_UART3_SHIFT)) & RCC_APB1ENR_UART3_MASK) + +#define RCC_APB1ENR_UART2_SHIFT (17) +#define RCC_APB1ENR_UART2_MASK (0x01U << RCC_APB1ENR_UART2_SHIFT) +#define RCC_APB1ENR_UART2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_UART2_SHIFT)) & RCC_APB1ENR_UART2_MASK) + +#define RCC_APB1ENR_SPI3_SHIFT (15) +#define RCC_APB1ENR_SPI3_MASK (0x01U << RCC_APB1ENR_SPI3_SHIFT) +#define RCC_APB1ENR_SPI3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_SPI3_SHIFT)) & RCC_APB1ENR_SPI3_MASK) + +#define RCC_APB1ENR_SPI2_SHIFT (14) +#define RCC_APB1ENR_SPI2_MASK (0x01U << RCC_APB1ENR_SPI2_SHIFT) +#define RCC_APB1ENR_SPI2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_SPI2_SHIFT)) & RCC_APB1ENR_SPI2_MASK) + +#define RCC_APB1ENR_WWDG_SHIFT (11) +#define RCC_APB1ENR_WWDG_MASK (0x01U << RCC_APB1ENR_WWDG_SHIFT) +#define RCC_APB1ENR_WWDG(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_WWDG_SHIFT)) & RCC_APB1ENR_WWDG_MASK) + +#define RCC_APB1ENR_TIM7_SHIFT (5) +#define RCC_APB1ENR_TIM7_MASK (0x01U << RCC_APB1ENR_TIM7_SHIFT) +#define RCC_APB1ENR_TIM7(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_TIM7_SHIFT)) & RCC_APB1ENR_TIM7_MASK) + +#define RCC_APB1ENR_TIM6_SHIFT (4) +#define RCC_APB1ENR_TIM6_MASK (0x01U << RCC_APB1ENR_TIM6_SHIFT) +#define RCC_APB1ENR_TIM6(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_TIM6_SHIFT)) & RCC_APB1ENR_TIM6_MASK) + +#define RCC_APB1ENR_TIM5_SHIFT (3) +#define RCC_APB1ENR_TIM5_MASK (0x01U << RCC_APB1ENR_TIM5_SHIFT) +#define RCC_APB1ENR_TIM5(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_TIM5_SHIFT)) & RCC_APB1ENR_TIM5_MASK) + +#define RCC_APB1ENR_TIM4_SHIFT (2) +#define RCC_APB1ENR_TIM4_MASK (0x01U << RCC_APB1ENR_TIM4_SHIFT) +#define RCC_APB1ENR_TIM4(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_TIM4_SHIFT)) & RCC_APB1ENR_TIM4_MASK) + +#define RCC_APB1ENR_TIM3_SHIFT (1) +#define RCC_APB1ENR_TIM3_MASK (0x01U << RCC_APB1ENR_TIM3_SHIFT) +#define RCC_APB1ENR_TIM3(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_TIM3_SHIFT)) & RCC_APB1ENR_TIM3_MASK) + +#define RCC_APB1ENR_TIM2_SHIFT (0) +#define RCC_APB1ENR_TIM2_MASK (0x01U << RCC_APB1ENR_TIM2_SHIFT) +#define RCC_APB1ENR_TIM2(x) (((uint32_t)(((uint32_t)(x)) << RCC_APB1ENR_TIM2_SHIFT)) & RCC_APB1ENR_TIM2_MASK) + +/*! + * @brief RCC_BDCR Register Bit Definition + */ + +#define RCC_BDCR_DBP_SHIFT (24) +#define RCC_BDCR_DBP_MASK (0x01U << RCC_BDCR_DBP_SHIFT) +#define RCC_BDCR_DBP(x) (((uint32_t)(((uint32_t)(x)) << RCC_BDCR_DBP_SHIFT)) & RCC_BDCR_DBP_MASK) + +#define RCC_BDCR_BDRST_SHIFT (16) +#define RCC_BDCR_BDRST_MASK (0x01U << RCC_BDCR_BDRST_SHIFT) +#define RCC_BDCR_BDRST(x) (((uint32_t)(((uint32_t)(x)) << RCC_BDCR_BDRST_SHIFT)) & RCC_BDCR_BDRST_MASK) + +#define RCC_BDCR_RTCEN_SHIFT (15) +#define RCC_BDCR_RTCEN_MASK (0x01U << RCC_BDCR_RTCEN_SHIFT) +#define RCC_BDCR_RTCEN(x) (((uint32_t)(((uint32_t)(x)) << RCC_BDCR_RTCEN_SHIFT)) & RCC_BDCR_RTCEN_MASK) + +#define RCC_BDCR_RTCSEL_SHIFT (8) +#define RCC_BDCR_RTCSEL_MASK (0x3U << RCC_BDCR_RTCSEL_SHIFT) +#define RCC_BDCR_RTCSEL(x) (((uint32_t)(((uint32_t)(x)) << RCC_BDCR_RTCSEL_SHIFT)) & RCC_BDCR_RTCSEL_MASK) + +#define RCC_BDCR_LSEBYP_SHIFT (2) +#define RCC_BDCR_LSEBYP_MASK (0x01U << RCC_BDCR_LSEBYP_SHIFT) +#define RCC_BDCR_LSEBYP(x) (((uint32_t)(((uint32_t)(x)) << RCC_BDCR_LSEBYP_SHIFT)) & RCC_BDCR_LSEBYP_MASK) + +#define RCC_BDCR_LSERDY_SHIFT (1) +#define RCC_BDCR_LSERDY_MASK (0x01U << RCC_BDCR_LSERDY_SHIFT) +#define RCC_BDCR_LSERDY(x) (((uint32_t)(((uint32_t)(x)) << RCC_BDCR_LSERDY_SHIFT)) & RCC_BDCR_LSERDY_MASK) + +#define RCC_BDCR_LSEON_SHIFT (0) +#define RCC_BDCR_LSEON_MASK (0x01U << RCC_BDCR_LSEON_SHIFT) +#define RCC_BDCR_LSEON(x) (((uint32_t)(((uint32_t)(x)) << RCC_BDCR_LSEON_SHIFT)) & RCC_BDCR_LSEON_MASK) + +/*! + * @brief RCC_CSR Register Bit Definition + */ + +#define RCC_CSR_LPWRRSTF_SHIFT (31) +#define RCC_CSR_LPWRRSTF_MASK (0x01U << RCC_CSR_LPWRRSTF_SHIFT) +#define RCC_CSR_LPWRRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_LPWRRSTF_SHIFT)) & RCC_CSR_LPWRRSTF_MASK) + +#define RCC_CSR_WWDGRSTF_SHIFT (30) +#define RCC_CSR_WWDGRSTF_MASK (0x01U << RCC_CSR_WWDGRSTF_SHIFT) +#define RCC_CSR_WWDGRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_WWDGRSTF_SHIFT)) & RCC_CSR_WWDGRSTF_MASK) + +#define RCC_CSR_IWDGRSTF_SHIFT (29) +#define RCC_CSR_IWDGRSTF_MASK (0x01U << RCC_CSR_IWDGRSTF_SHIFT) +#define RCC_CSR_IWDGRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_IWDGRSTF_SHIFT)) & RCC_CSR_IWDGRSTF_MASK) + +#define RCC_CSR_SFTRSTF_SHIFT (28) +#define RCC_CSR_SFTRSTF_MASK (0x01U << RCC_CSR_SFTRSTF_SHIFT) +#define RCC_CSR_SFTRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_SFTRSTF_SHIFT)) & RCC_CSR_SFTRSTF_MASK) + +#define RCC_CSR_PORRSTF_SHIFT (27) +#define RCC_CSR_PORRSTF_MASK (0x01U << RCC_CSR_PORRSTF_SHIFT) +#define RCC_CSR_PORRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_PORRSTF_SHIFT)) & RCC_CSR_PORRSTF_MASK) + +#define RCC_CSR_PINRSTF_SHIFT (26) +#define RCC_CSR_PINRSTF_MASK (0x01U << RCC_CSR_PINRSTF_SHIFT) +#define RCC_CSR_PINRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_PINRSTF_SHIFT)) & RCC_CSR_PINRSTF_MASK) + +#define RCC_CSR_RMVF_SHIFT (24) +#define RCC_CSR_RMVF_MASK (0x01U << RCC_CSR_RMVF_SHIFT) +#define RCC_CSR_RMVF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_RMVF_SHIFT)) & RCC_CSR_RMVF_MASK) + +#define RCC_CSR_LOCKUPF_SHIFT (23) +#define RCC_CSR_LOCKUPF_MASK (0x01U << RCC_CSR_LOCKUPF_SHIFT) +#define RCC_CSR_LOCKUPF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_LOCKUPF_SHIFT)) & RCC_CSR_LOCKUPF_MASK) + +#define RCC_CSR_PVDRSTF_SHIFT (22) +#define RCC_CSR_PVDRSTF_MASK (0x01U << RCC_CSR_PVDRSTF_SHIFT) +#define RCC_CSR_PVDRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_PVDRSTF_SHIFT)) & RCC_CSR_PVDRSTF_MASK) + +#define RCC_CSR_VDTRSTF_SHIFT (21) +#define RCC_CSR_VDTRSTF_MASK (0x01U << RCC_CSR_VDTRSTF_SHIFT) +#define RCC_CSR_VDTRSTF(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_VDTRSTF_SHIFT)) & RCC_CSR_VDTRSTF_MASK) + +#define RCC_CSR_VDTRSTNEN_SHIFT (8) +#define RCC_CSR_VDTRSTNEN_MASK (0x01U << RCC_CSR_VDTRSTNEN_SHIFT) +#define RCC_CSR_VDTRSTNEN(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_VDTRSTNEN_SHIFT)) & RCC_CSR_VDTRSTNEN_MASK) + +#define RCC_CSR_LOCKUPEN_SHIFT (7) +#define RCC_CSR_LOCKUPEN_MASK (0x01U << RCC_CSR_LOCKUPEN_SHIFT) +#define RCC_CSR_LOCKUPEN(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_LOCKUPEN_SHIFT)) & RCC_CSR_LOCKUPEN_MASK) + +#define RCC_CSR_PVDRSTEN_SHIFT (6) +#define RCC_CSR_PVDRSTEN_MASK (0x01U << RCC_CSR_PVDRSTEN_SHIFT) +#define RCC_CSR_PVDRSTEN(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_PVDRSTEN_SHIFT)) & RCC_CSR_PVDRSTEN_MASK) + +#define RCC_CSR_LSIOENLV_SHIFT (5) +#define RCC_CSR_LSIOENLV_MASK (0x01U << RCC_CSR_LSIOENLV_SHIFT) +#define RCC_CSR_LSIOENLV(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_LSIOENLV_SHIFT)) & RCC_CSR_LSIOENLV_MASK) + +#define RCC_CSR_LSIRDY_SHIFT (1) +#define RCC_CSR_LSIRDY_MASK (0x01U << RCC_CSR_LSIRDY_SHIFT) +#define RCC_CSR_LSIRDY(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_LSIRDY_SHIFT)) & RCC_CSR_LSIRDY_MASK) + +#define RCC_CSR_LSION_SHIFT (0) +#define RCC_CSR_LSION_MASK (0x01U << RCC_CSR_LSION_SHIFT) +#define RCC_CSR_LSION(x) (((uint32_t)(((uint32_t)(x)) << RCC_CSR_LSION_SHIFT)) & RCC_CSR_LSION_MASK) + +/*! + * @brief RCC_SYSCFG Register Bit Definition + */ + +#define RCC_SYSCFG_OSCLPFEN_SHIFT (14) +#define RCC_SYSCFG_OSCLPFEN_MASK (0x01U << RCC_SYSCFG_OSCLPFEN_SHIFT) +#define RCC_SYSCFG_OSCLPFEN(x) (((uint32_t)(((uint32_t)(x)) << RCC_SYSCFG_OSCLPFEN_SHIFT)) & RCC_SYSCFG_OSCLPFEN_MASK) + +#define RCC_SYSCFG_PADOSCTRIM_SHIFT (8) +#define RCC_SYSCFG_PADOSCTRIM_MASK (0x1FU << RCC_SYSCFG_PADOSCTRIM_SHIFT) +#define RCC_SYSCFG_PADOSCTRIM(x) (((uint32_t)(((uint32_t)(x)) << RCC_SYSCFG_PADOSCTRIM_SHIFT)) & RCC_SYSCFG_PADOSCTRIM_MASK) + +#define RCC_SYSCFG_DATAPREFETCH_SHIFT (2) +#define RCC_SYSCFG_DATAPREFETCH_MASK (0x01U << RCC_SYSCFG_DATAPREFETCH_SHIFT) +#define RCC_SYSCFG_DATAPREFETCH(x) (((uint32_t)(((uint32_t)(x)) << RCC_SYSCFG_DATAPREFETCH_SHIFT)) & RCC_SYSCFG_DATAPREFETCH_MASK) + +#define RCC_SYSCFG_SECTOR1KCFG_SHIFT (1) +#define RCC_SYSCFG_SECTOR1KCFG_MASK (0x01U << RCC_SYSCFG_SECTOR1KCFG_SHIFT) +#define RCC_SYSCFG_SECTOR1KCFG(x) (((uint32_t)(((uint32_t)(x)) << RCC_SYSCFG_SECTOR1KCFG_SHIFT)) & RCC_SYSCFG_SECTOR1KCFG_MASK) + +#define RCC_SYSCFG_PROGCHECKEN_SHIFT (0) +#define RCC_SYSCFG_PROGCHECKEN_MASK (0x01U << RCC_SYSCFG_PROGCHECKEN_SHIFT) +#define RCC_SYSCFG_PROGCHECKEN(x) (((uint32_t)(((uint32_t)(x)) << RCC_SYSCFG_PROGCHECKEN_SHIFT)) & RCC_SYSCFG_PROGCHECKEN_MASK) + +/*! + * @brief RCC_CFGR2 Register Bit Definition + */ + +#define RCC_CFGR2_APB1CLKHVPRE_SHIFT (16) +#define RCC_CFGR2_APB1CLKHVPRE_MASK (0xFU << RCC_CFGR2_APB1CLKHVPRE_SHIFT) +#define RCC_CFGR2_APB1CLKHVPRE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR2_APB1CLKHVPRE_SHIFT)) & RCC_CFGR2_APB1CLKHVPRE_MASK) + +#define RCC_CFGR2_FSMCPRE_SHIFT (8) +#define RCC_CFGR2_FSMCPRE_MASK (0x1FU << RCC_CFGR2_FSMCPRE_SHIFT) +#define RCC_CFGR2_FSMCPRE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR2_FSMCPRE_SHIFT)) & RCC_CFGR2_FSMCPRE_MASK) + +#define RCC_CFGR2_TIMADVPRE_SHIFT (1) +#define RCC_CFGR2_TIMADVPRE_MASK (0x7U << RCC_CFGR2_TIMADVPRE_SHIFT) +#define RCC_CFGR2_TIMADVPRE(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR2_TIMADVPRE_SHIFT)) & RCC_CFGR2_TIMADVPRE_MASK) + +#define RCC_CFGR2_TIMADVCKSEL_SHIFT (0) +#define RCC_CFGR2_TIMADVCKSEL_MASK (0x01U << RCC_CFGR2_TIMADVCKSEL_SHIFT) +#define RCC_CFGR2_TIMADVCKSEL(x) (((uint32_t)(((uint32_t)(x)) << RCC_CFGR2_TIMADVCKSEL_SHIFT)) & RCC_CFGR2_TIMADVCKSEL_MASK) + +/*! + * @brief RCC_ICSCR Register Bit Definition + */ + +#define RCC_ICSCR_HSICALSFT_SHIFT (16) +#define RCC_ICSCR_HSICALSFT_MASK (0x3FFU << RCC_ICSCR_HSICALSFT_SHIFT) +#define RCC_ICSCR_HSICALSFT(x) (((uint32_t)(((uint32_t)(x)) << RCC_ICSCR_HSICALSFT_SHIFT)) & RCC_ICSCR_HSICALSFT_MASK) + +#define RCC_ICSCR_HSICALSEL_SHIFT (11) +#define RCC_ICSCR_HSICALSEL_MASK (0x1FU << RCC_ICSCR_HSICALSEL_SHIFT) +#define RCC_ICSCR_HSICALSEL(x) (((uint32_t)(((uint32_t)(x)) << RCC_ICSCR_HSICALSEL_SHIFT)) & RCC_ICSCR_HSICALSEL_MASK) + +#define RCC_ICSCR_TRIMCRSSEL_SHIFT (0) +#define RCC_ICSCR_TRIMCRSSEL_MASK (0x01U << RCC_ICSCR_TRIMCRSSEL_SHIFT) +#define RCC_ICSCR_TRIMCRSSEL(x) (((uint32_t)(((uint32_t)(x)) << RCC_ICSCR_TRIMCRSSEL_SHIFT)) & RCC_ICSCR_TRIMCRSSEL_MASK) + +/*! + * @brief RCC_PLLCFGR Register Bit Definition + */ + +#define RCC_PLLCFGR_PLLMUL_SHIFT (16) +#define RCC_PLLCFGR_PLLMUL_MASK (0x7FU << RCC_PLLCFGR_PLLMUL_SHIFT) +#define RCC_PLLCFGR_PLLMUL(x) (((uint32_t)(((uint32_t)(x)) << RCC_PLLCFGR_PLLMUL_SHIFT)) & RCC_PLLCFGR_PLLMUL_MASK) + +#define RCC_PLLCFGR_PLLDIV_SHIFT (8) +#define RCC_PLLCFGR_PLLDIV_MASK (0x7U << RCC_PLLCFGR_PLLDIV_SHIFT) +#define RCC_PLLCFGR_PLLDIV(x) (((uint32_t)(((uint32_t)(x)) << RCC_PLLCFGR_PLLDIV_SHIFT)) & RCC_PLLCFGR_PLLDIV_MASK) + +#define RCC_PLLCFGR_PLLLDS_SHIFT (4) +#define RCC_PLLCFGR_PLLLDS_MASK (0x3U << RCC_PLLCFGR_PLLLDS_SHIFT) +#define RCC_PLLCFGR_PLLLDS(x) (((uint32_t)(((uint32_t)(x)) << RCC_PLLCFGR_PLLLDS_SHIFT)) & RCC_PLLCFGR_PLLLDS_MASK) + +#define RCC_PLLCFGR_PLLICTRL_SHIFT (2) +#define RCC_PLLCFGR_PLLICTRL_MASK (0x3U << RCC_PLLCFGR_PLLICTRL_SHIFT) +#define RCC_PLLCFGR_PLLICTRL(x) (((uint32_t)(((uint32_t)(x)) << RCC_PLLCFGR_PLLICTRL_SHIFT)) & RCC_PLLCFGR_PLLICTRL_MASK) + +#define RCC_PLLCFGR_PLLXTPRE_SHIFT (1) +#define RCC_PLLCFGR_PLLXTPRE_MASK (0x01U << RCC_PLLCFGR_PLLXTPRE_SHIFT) +#define RCC_PLLCFGR_PLLXTPRE(x) (((uint32_t)(((uint32_t)(x)) << RCC_PLLCFGR_PLLXTPRE_SHIFT)) & RCC_PLLCFGR_PLLXTPRE_MASK) + +#define RCC_PLLCFGR_PLLSRC_SHIFT (0) +#define RCC_PLLCFGR_PLLSRC_MASK (0x01U << RCC_PLLCFGR_PLLSRC_SHIFT) +#define RCC_PLLCFGR_PLLSRC(x) (((uint32_t)(((uint32_t)(x)) << RCC_PLLCFGR_PLLSRC_SHIFT)) & RCC_PLLCFGR_PLLSRC_MASK) + +/*! + * @brief RCC_HSIDLY Register Bit Definition + */ + +#define RCC_HSIDLY_HSIEQUCNT_SHIFT (0) +#define RCC_HSIDLY_HSIEQUCNT_MASK (0xFFU << RCC_HSIDLY_HSIEQUCNT_SHIFT) +#define RCC_HSIDLY_HSIEQUCNT(x) (((uint32_t)(((uint32_t)(x)) << RCC_HSIDLY_HSIEQUCNT_SHIFT)) & RCC_HSIDLY_HSIEQUCNT_MASK) + +/*! + * @brief RCC_HSEDLY Register Bit Definition + */ + +#define RCC_HSEDLY_HSEEQUCNT_SHIFT (0) +#define RCC_HSEDLY_HSEEQUCNT_MASK (0xFFFFU << RCC_HSEDLY_HSEEQUCNT_SHIFT) +#define RCC_HSEDLY_HSEEQUCNT(x) (((uint32_t)(((uint32_t)(x)) << RCC_HSEDLY_HSEEQUCNT_SHIFT)) & RCC_HSEDLY_HSEEQUCNT_MASK) + +/*! + * @brief RCC_PLLDLY Register Bit Definition + */ + +#define RCC_PLLDLY_PLLEQUCNT_SHIFT (0) +#define RCC_PLLDLY_PLLEQUCNT_MASK (0x3FFU << RCC_PLLDLY_PLLEQUCNT_SHIFT) +#define RCC_PLLDLY_PLLEQUCNT(x) (((uint32_t)(((uint32_t)(x)) << RCC_PLLDLY_PLLEQUCNT_SHIFT)) & RCC_PLLDLY_PLLEQUCNT_MASK) + +/*! + * @} + */ /* end of group RCC_Register_Masks */ +/****************************************************************************** + * RCC Instance +******************************************************************************/ +#define RCC ((RCC_Type*)RCC_BASE) + +/*! + * @} + */ /* end of group RCC_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup SYSCFG_Peripheral_Access_Layer SYSCFG Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * SYSCFG Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CFGR; ///< SYSCFG configuration register offset: 0x00 + __IO uint32_t Reserved4[1]; ///< Reserved + __IO uint32_t EXTICR1; ///< External interrupt configuration register 1 offset: 0x08 + __IO uint32_t EXTICR2; ///< External interrupt configuration register 2 offset: 0x0C + __IO uint32_t EXTICR3; ///< External interrupt configuration register 3 offset: 0x10 + __IO uint32_t EXTICR4; ///< External interrupt configuration register 4 offset: 0x14 + __IO uint32_t CFGR2; ///< SYSCFG configuration register 2 offset: 0x18 + __IO uint32_t PDETCSR; ///< Power detection configuration status registeroffset: 0x1C + __IO uint32_t VOSDLY; ///< VOSDLY configuration register offset: 0x20 +} SYSCFG_Type; + +/******************************************************************************* + * SYSCFG Type + ******************************************************************************/ + +/*! + * @addtogroup SYSCFG_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief SYSCFG_CFGR Register Bit Definition + */ + +#define SYSCFG_CFGR_MODESEL_SHIFT (29) +#define SYSCFG_CFGR_MODESEL_MASK (0x3U << SYSCFG_CFGR_MODESEL_SHIFT) +#define SYSCFG_CFGR_MODESEL(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_CFGR_MODESEL_SHIFT)) & SYSCFG_CFGR_MODESEL_MASK) + +#define SYSCFG_CFGR_FCODATAEN_SHIFT (28) +#define SYSCFG_CFGR_FCODATAEN_MASK (0x01U << SYSCFG_CFGR_FCODATAEN_SHIFT) +#define SYSCFG_CFGR_FCODATAEN(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_CFGR_FCODATAEN_SHIFT)) & SYSCFG_CFGR_FCODATAEN_MASK) + +#define SYSCFG_CFGR_MEMMODE_SHIFT (0) +#define SYSCFG_CFGR_MEMMODE_MASK (0x3U << SYSCFG_CFGR_MEMMODE_SHIFT) +#define SYSCFG_CFGR_MEMMODE(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_CFGR_MEMMODE_SHIFT)) & SYSCFG_CFGR_MEMMODE_MASK) + +/*! + * @brief SYSCFG_EXTICR1 Register Bit Definition + */ + +#define SYSCFG_EXTICR1_EXTIX_SHIFT (0) +#define SYSCFG_EXTICR1_EXTIX_MASK (0xFFFFU << SYSCFG_EXTICR1_EXTIX_SHIFT) +#define SYSCFG_EXTICR1_EXTIX(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_EXTICR1_EXTIX_SHIFT)) & SYSCFG_EXTICR1_EXTIX_MASK) + +/*! + * @brief SYSCFG_EXTICR2 Register Bit Definition + */ + +#define SYSCFG_EXTICR2_EXTIX_SHIFT (0) +#define SYSCFG_EXTICR2_EXTIX_MASK (0xFFFFU << SYSCFG_EXTICR2_EXTIX_SHIFT) +#define SYSCFG_EXTICR2_EXTIX(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_EXTICR2_EXTIX_SHIFT)) & SYSCFG_EXTICR2_EXTIX_MASK) + +/*! + * @brief SYSCFG_EXTICR3 Register Bit Definition + */ + +#define SYSCFG_EXTICR3_EXTIX_SHIFT (0) +#define SYSCFG_EXTICR3_EXTIX_MASK (0xFFFFU << SYSCFG_EXTICR3_EXTIX_SHIFT) +#define SYSCFG_EXTICR3_EXTIX(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_EXTICR3_EXTIX_SHIFT)) & SYSCFG_EXTICR3_EXTIX_MASK) + +/*! + * @brief SYSCFG_EXTICR4 Register Bit Definition + */ + +#define SYSCFG_EXTICR4_EXTIX_SHIFT (0) +#define SYSCFG_EXTICR4_EXTIX_MASK (0xFFFFU << SYSCFG_EXTICR4_EXTIX_SHIFT) +#define SYSCFG_EXTICR4_EXTIX(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_EXTICR4_EXTIX_SHIFT)) & SYSCFG_EXTICR4_EXTIX_MASK) + +/*! + * @brief SYSCFG_CFGR2 Register Bit Definition + */ + +#define SYSCFG_CFGR2_MACSPDSEL_SHIFT (21) +#define SYSCFG_CFGR2_MACSPDSEL_MASK (0x01U << SYSCFG_CFGR2_MACSPDSEL_SHIFT) +#define SYSCFG_CFGR2_MACSPDSEL(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_CFGR2_MACSPDSEL_SHIFT)) & SYSCFG_CFGR2_MACSPDSEL_MASK) + +#define SYSCFG_CFGR2_MIIRMIISEL_SHIFT (20) +#define SYSCFG_CFGR2_MIIRMIISEL_MASK (0x01U << SYSCFG_CFGR2_MIIRMIISEL_SHIFT) +#define SYSCFG_CFGR2_MIIRMIISEL(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_CFGR2_MIIRMIISEL_SHIFT)) & SYSCFG_CFGR2_MIIRMIISEL_MASK) + +#define SYSCFG_CFGR2_I2C2MODESEL_SHIFT (17) +#define SYSCFG_CFGR2_I2C2MODESEL_MASK (0x01U << SYSCFG_CFGR2_I2C2MODESEL_SHIFT) +#define SYSCFG_CFGR2_I2C2MODESEL(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_CFGR2_I2C2MODESEL_SHIFT)) & SYSCFG_CFGR2_I2C2MODESEL_MASK) + +#define SYSCFG_CFGR2_I2C1MODESEL_SHIFT (16) +#define SYSCFG_CFGR2_I2C1MODESEL_MASK (0x01U << SYSCFG_CFGR2_I2C1MODESEL_SHIFT) +#define SYSCFG_CFGR2_I2C1MODESEL(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_CFGR2_I2C1MODESEL_SHIFT)) & SYSCFG_CFGR2_I2C1MODESEL_MASK) + +/*! + * @brief SYSCFG_PDETCSR Register Bit Definition + */ + +#define SYSCFG_PDETCSR_VBATDIV3EN_SHIFT (11) +#define SYSCFG_PDETCSR_VBATDIV3EN_MASK (0x01U << SYSCFG_PDETCSR_VBATDIV3EN_SHIFT) +#define SYSCFG_PDETCSR_VBATDIV3EN(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_PDETCSR_VBATDIV3EN_SHIFT)) & SYSCFG_PDETCSR_VBATDIV3EN_MASK) + +#define SYSCFG_PDETCSR_VDTLS_SHIFT (9) +#define SYSCFG_PDETCSR_VDTLS_MASK (0x3U << SYSCFG_PDETCSR_VDTLS_SHIFT) +#define SYSCFG_PDETCSR_VDTLS(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_PDETCSR_VDTLS_SHIFT)) & SYSCFG_PDETCSR_VDTLS_MASK) + +#define SYSCFG_PDETCSR_VDTE_SHIFT (8) +#define SYSCFG_PDETCSR_VDTE_MASK (0x01U << SYSCFG_PDETCSR_VDTE_SHIFT) +#define SYSCFG_PDETCSR_VDTE(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_PDETCSR_VDTE_SHIFT)) & SYSCFG_PDETCSR_VDTE_MASK) + +#define SYSCFG_PDETCSR_VDTO_SHIFT (6) +#define SYSCFG_PDETCSR_VDTO_MASK (0x01U << SYSCFG_PDETCSR_VDTO_SHIFT) +#define SYSCFG_PDETCSR_VDTO(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_PDETCSR_VDTO_SHIFT)) & SYSCFG_PDETCSR_VDTO_MASK) + +#define SYSCFG_PDETCSR_PVDO_SHIFT (5) +#define SYSCFG_PDETCSR_PVDO_MASK (0x01U << SYSCFG_PDETCSR_PVDO_SHIFT) +#define SYSCFG_PDETCSR_PVDO(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_PDETCSR_PVDO_SHIFT)) & SYSCFG_PDETCSR_PVDO_MASK) + +#define SYSCFG_PDETCSR_PLS_SHIFT (1) +#define SYSCFG_PDETCSR_PLS_MASK (0xFU << SYSCFG_PDETCSR_PLS_SHIFT) +#define SYSCFG_PDETCSR_PLS(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_PDETCSR_PLS_SHIFT)) & SYSCFG_PDETCSR_PLS_MASK) + +#define SYSCFG_PDETCSR_PVDE_SHIFT (0) +#define SYSCFG_PDETCSR_PVDE_MASK (0x01U << SYSCFG_PDETCSR_PVDE_SHIFT) +#define SYSCFG_PDETCSR_PVDE(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_PDETCSR_PVDE_SHIFT)) & SYSCFG_PDETCSR_PVDE_MASK) + +/*! + * @brief SYSCFG_VOSDLY Register Bit Definition + */ + +#define SYSCFG_VOSDLY_VOSDLYCNT_SHIFT (0) +#define SYSCFG_VOSDLY_VOSDLYCNT_MASK (0x3FFU << SYSCFG_VOSDLY_VOSDLYCNT_SHIFT) +#define SYSCFG_VOSDLY_VOSDLYCNT(x) (((uint32_t)(((uint32_t)(x)) << SYSCFG_VOSDLY_VOSDLYCNT_SHIFT)) & SYSCFG_VOSDLY_VOSDLYCNT_MASK) + +/*! + * @} + */ /* end of group SYSCFG_Register_Masks */ +/****************************************************************************** + * SYSCFG Instance +******************************************************************************/ +#define SYSCFG ((SYSCFG_Type*)SYSCFG_BASE) + +/*! + * @} + */ /* end of group SYSCFG_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup EXTI_Peripheral_Access_Layer EXTI Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * EXTI Type + ******************************************************************************/ +typedef struct { + __IO uint32_t IMR; ///< Interrupt mask register offset: 0x00 + __IO uint32_t EMR; ///< Event mask register offset: 0x04 + __IO uint32_t RTSR; ///< Rising edge trigger selection register offset: 0x08 + __IO uint32_t FTSR; ///< Falling edge trigger selection register offset: 0x0C + __IO uint32_t SWIER; ///< Software interrupt event register offset: 0x10 + __IO uint32_t PR; ///< Pending register offset: 0x14 +} EXTI_Type; + +/******************************************************************************* + * EXTI Type + ******************************************************************************/ + +/*! + * @addtogroup EXTI_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief EXTI_IMR Register Bit Definition + */ + +#define EXTI_IMR_IMRX_SHIFT (0) +#define EXTI_IMR_IMRX_MASK (0xFFFFFFFFU << EXTI_IMR_IMRX_SHIFT) +#define EXTI_IMR_IMRX(x) (((uint32_t)(((uint32_t)(x)) << EXTI_IMR_IMRX_SHIFT)) & EXTI_IMR_IMRX_MASK) + +/*! + * @brief EXTI_EMR Register Bit Definition + */ + +#define EXTI_EMR_EMRX_SHIFT (0) +#define EXTI_EMR_EMRX_MASK (0xFFFFFFFFU << EXTI_EMR_EMRX_SHIFT) +#define EXTI_EMR_EMRX(x) (((uint32_t)(((uint32_t)(x)) << EXTI_EMR_EMRX_SHIFT)) & EXTI_EMR_EMRX_MASK) + +/*! + * @brief EXTI_RTSR Register Bit Definition + */ + +#define EXTI_RTSR_TRX_SHIFT (0) +#define EXTI_RTSR_TRX_MASK (0xFFFFFFFFU << EXTI_RTSR_TRX_SHIFT) +#define EXTI_RTSR_TRX(x) (((uint32_t)(((uint32_t)(x)) << EXTI_RTSR_TRX_SHIFT)) & EXTI_RTSR_TRX_MASK) + +/*! + * @brief EXTI_FTSR Register Bit Definition + */ + +#define EXTI_FTSR_TRX_SHIFT (0) +#define EXTI_FTSR_TRX_MASK (0xFFFFFFFFU << EXTI_FTSR_TRX_SHIFT) +#define EXTI_FTSR_TRX(x) (((uint32_t)(((uint32_t)(x)) << EXTI_FTSR_TRX_SHIFT)) & EXTI_FTSR_TRX_MASK) + +/*! + * @brief EXTI_SWIER Register Bit Definition + */ + +#define EXTI_SWIER_SWIERX_SHIFT (0) +#define EXTI_SWIER_SWIERX_MASK (0x3FFFFFU << EXTI_SWIER_SWIERX_SHIFT) +#define EXTI_SWIER_SWIERX(x) (((uint32_t)(((uint32_t)(x)) << EXTI_SWIER_SWIERX_SHIFT)) & EXTI_SWIER_SWIERX_MASK) + +#define EXTI_SWIER_SWIERX_SHIFT (0) +#define EXTI_SWIER_SWIERX_MASK (0x3FFFFFU << EXTI_SWIER_SWIERX_SHIFT) +#define EXTI_SWIER_SWIERX(x) (((uint32_t)(((uint32_t)(x)) << EXTI_SWIER_SWIERX_SHIFT)) & EXTI_SWIER_SWIERX_MASK) + +/*! + * @brief EXTI_PR Register Bit Definition + */ + +#define EXTI_PR_PRX_SHIFT (0) +#define EXTI_PR_PRX_MASK (0x3FFFFFU << EXTI_PR_PRX_SHIFT) +#define EXTI_PR_PRX(x) (((uint32_t)(((uint32_t)(x)) << EXTI_PR_PRX_SHIFT)) & EXTI_PR_PRX_MASK) + +/*! + * @} + */ /* end of group EXTI_Register_Masks */ +/****************************************************************************** + * EXTI Instance +******************************************************************************/ +#define EXTI ((EXTI_Type*)EXTI_BASE) + +/*! + * @} + */ /* end of group EXTI_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup DMA_Peripheral_Access_Layer DMA Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * DMA Type + ******************************************************************************/ +#define DMA_CHANNEL_COUNT 7u + +typedef struct { + __IO uint32_t ISR; ///< DMAinterruptstatusregister offset: 0x00 + __IO uint32_t IFCR; ///< DMAinterruptflagclearregister offset: 0x04 + struct { + __IO uint32_t CCR; ///< DMAchannelxconfigurationregister offset: 0x08 + __IO uint32_t CNDTR; ///< DMAchannelxtransferquantityregister offset: 0x0C + __IO uint32_t CPAR; ///< DMAchannelxperipheraladdressregister offset: 0x10 + __IO uint32_t CMAR; ///< DMAchannelxmemoryaddressregister offset: 0x14 + __IO uint32_t Reserved0; + } CH[DMA_CHANNEL_COUNT]; + +} DMA_Type; +/******************************************************************************* + * DMA Type + ******************************************************************************/ + +/*! + * @addtogroup DMA_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief DMA_ISR Register Bit Definition + */ + +#define DMA_ISR_TEIF7_SHIFT (27) +#define DMA_ISR_TEIF7_MASK (0x01U << DMA_ISR_TEIF7_SHIFT) +#define DMA_ISR_TEIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TEIF7_SHIFT)) & DMA_ISR_TEIF7_MASK) + +#define DMA_ISR_HTIF7_SHIFT (26) +#define DMA_ISR_HTIF7_MASK (0x01U << DMA_ISR_HTIF7_SHIFT) +#define DMA_ISR_HTIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_HTIF7_SHIFT)) & DMA_ISR_HTIF7_MASK) + +#define DMA_ISR_TCIF7_SHIFT (25) +#define DMA_ISR_TCIF7_MASK (0x01U << DMA_ISR_TCIF7_SHIFT) +#define DMA_ISR_TCIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TCIF7_SHIFT)) & DMA_ISR_TCIF7_MASK) + +#define DMA_ISR_GIF7_SHIFT (24) +#define DMA_ISR_GIF7_MASK (0x01U << DMA_ISR_GIF7_SHIFT) +#define DMA_ISR_GIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_GIF7_SHIFT)) & DMA_ISR_GIF7_MASK) + +#define DMA_ISR_TEIF6_SHIFT (23) +#define DMA_ISR_TEIF6_MASK (0x01U << DMA_ISR_TEIF6_SHIFT) +#define DMA_ISR_TEIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TEIF6_SHIFT)) & DMA_ISR_TEIF6_MASK) + +#define DMA_ISR_HTIF6_SHIFT (22) +#define DMA_ISR_HTIF6_MASK (0x01U << DMA_ISR_HTIF6_SHIFT) +#define DMA_ISR_HTIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_HTIF6_SHIFT)) & DMA_ISR_HTIF6_MASK) + +#define DMA_ISR_TCIF6_SHIFT (21) +#define DMA_ISR_TCIF6_MASK (0x01U << DMA_ISR_TCIF6_SHIFT) +#define DMA_ISR_TCIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TCIF6_SHIFT)) & DMA_ISR_TCIF6_MASK) + +#define DMA_ISR_GIF6_SHIFT (20) +#define DMA_ISR_GIF6_MASK (0x01U << DMA_ISR_GIF6_SHIFT) +#define DMA_ISR_GIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_GIF6_SHIFT)) & DMA_ISR_GIF6_MASK) + +#define DMA_ISR_TEIF5_SHIFT (19) +#define DMA_ISR_TEIF5_MASK (0x01U << DMA_ISR_TEIF5_SHIFT) +#define DMA_ISR_TEIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TEIF5_SHIFT)) & DMA_ISR_TEIF5_MASK) + +#define DMA_ISR_HTIF5_SHIFT (18) +#define DMA_ISR_HTIF5_MASK (0x01U << DMA_ISR_HTIF5_SHIFT) +#define DMA_ISR_HTIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_HTIF5_SHIFT)) & DMA_ISR_HTIF5_MASK) + +#define DMA_ISR_TCIF5_SHIFT (17) +#define DMA_ISR_TCIF5_MASK (0x01U << DMA_ISR_TCIF5_SHIFT) +#define DMA_ISR_TCIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TCIF5_SHIFT)) & DMA_ISR_TCIF5_MASK) + +#define DMA_ISR_GIF5_SHIFT (16) +#define DMA_ISR_GIF5_MASK (0x01U << DMA_ISR_GIF5_SHIFT) +#define DMA_ISR_GIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_GIF5_SHIFT)) & DMA_ISR_GIF5_MASK) + +#define DMA_ISR_TEIF4_SHIFT (15) +#define DMA_ISR_TEIF4_MASK (0x01U << DMA_ISR_TEIF4_SHIFT) +#define DMA_ISR_TEIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TEIF4_SHIFT)) & DMA_ISR_TEIF4_MASK) + +#define DMA_ISR_HTIF4_SHIFT (14) +#define DMA_ISR_HTIF4_MASK (0x01U << DMA_ISR_HTIF4_SHIFT) +#define DMA_ISR_HTIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_HTIF4_SHIFT)) & DMA_ISR_HTIF4_MASK) + +#define DMA_ISR_TCIF4_SHIFT (13) +#define DMA_ISR_TCIF4_MASK (0x01U << DMA_ISR_TCIF4_SHIFT) +#define DMA_ISR_TCIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TCIF4_SHIFT)) & DMA_ISR_TCIF4_MASK) + +#define DMA_ISR_GIF4_SHIFT (12) +#define DMA_ISR_GIF4_MASK (0x01U << DMA_ISR_GIF4_SHIFT) +#define DMA_ISR_GIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_GIF4_SHIFT)) & DMA_ISR_GIF4_MASK) + +#define DMA_ISR_TEIF3_SHIFT (11) +#define DMA_ISR_TEIF3_MASK (0x01U << DMA_ISR_TEIF3_SHIFT) +#define DMA_ISR_TEIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TEIF3_SHIFT)) & DMA_ISR_TEIF3_MASK) + +#define DMA_ISR_HTIF3_SHIFT (10) +#define DMA_ISR_HTIF3_MASK (0x01U << DMA_ISR_HTIF3_SHIFT) +#define DMA_ISR_HTIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_HTIF3_SHIFT)) & DMA_ISR_HTIF3_MASK) + +#define DMA_ISR_TCIF3_SHIFT (9) +#define DMA_ISR_TCIF3_MASK (0x01U << DMA_ISR_TCIF3_SHIFT) +#define DMA_ISR_TCIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TCIF3_SHIFT)) & DMA_ISR_TCIF3_MASK) + +#define DMA_ISR_GIF3_SHIFT (8) +#define DMA_ISR_GIF3_MASK (0x01U << DMA_ISR_GIF3_SHIFT) +#define DMA_ISR_GIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_GIF3_SHIFT)) & DMA_ISR_GIF3_MASK) + +#define DMA_ISR_TEIF2_SHIFT (7) +#define DMA_ISR_TEIF2_MASK (0x01U << DMA_ISR_TEIF2_SHIFT) +#define DMA_ISR_TEIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TEIF2_SHIFT)) & DMA_ISR_TEIF2_MASK) + +#define DMA_ISR_HTIF2_SHIFT (6) +#define DMA_ISR_HTIF2_MASK (0x01U << DMA_ISR_HTIF2_SHIFT) +#define DMA_ISR_HTIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_HTIF2_SHIFT)) & DMA_ISR_HTIF2_MASK) + +#define DMA_ISR_TCIF2_SHIFT (5) +#define DMA_ISR_TCIF2_MASK (0x01U << DMA_ISR_TCIF2_SHIFT) +#define DMA_ISR_TCIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TCIF2_SHIFT)) & DMA_ISR_TCIF2_MASK) + +#define DMA_ISR_GIF2_SHIFT (4) +#define DMA_ISR_GIF2_MASK (0x01U << DMA_ISR_GIF2_SHIFT) +#define DMA_ISR_GIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_GIF2_SHIFT)) & DMA_ISR_GIF2_MASK) + +#define DMA_ISR_TEIF1_SHIFT (3) +#define DMA_ISR_TEIF1_MASK (0x01U << DMA_ISR_TEIF1_SHIFT) +#define DMA_ISR_TEIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TEIF1_SHIFT)) & DMA_ISR_TEIF1_MASK) + +#define DMA_ISR_HTIF1_SHIFT (2) +#define DMA_ISR_HTIF1_MASK (0x01U << DMA_ISR_HTIF1_SHIFT) +#define DMA_ISR_HTIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_HTIF1_SHIFT)) & DMA_ISR_HTIF1_MASK) + +#define DMA_ISR_TCIF1_SHIFT (1) +#define DMA_ISR_TCIF1_MASK (0x01U << DMA_ISR_TCIF1_SHIFT) +#define DMA_ISR_TCIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_TCIF1_SHIFT)) & DMA_ISR_TCIF1_MASK) + +#define DMA_ISR_GIF1_SHIFT (0) +#define DMA_ISR_GIF1_MASK (0x01U << DMA_ISR_GIF1_SHIFT) +#define DMA_ISR_GIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_ISR_GIF1_SHIFT)) & DMA_ISR_GIF1_MASK) + +/*! + * @brief DMA_IFCR Register Bit Definition + */ + +#define DMA_IFCR_CTEIF7_SHIFT (27) +#define DMA_IFCR_CTEIF7_MASK (0x01U << DMA_IFCR_CTEIF7_SHIFT) +#define DMA_IFCR_CTEIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTEIF7_SHIFT)) & DMA_IFCR_CTEIF7_MASK) + +#define DMA_IFCR_CHTIF7_SHIFT (26) +#define DMA_IFCR_CHTIF7_MASK (0x01U << DMA_IFCR_CHTIF7_SHIFT) +#define DMA_IFCR_CHTIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CHTIF7_SHIFT)) & DMA_IFCR_CHTIF7_MASK) + +#define DMA_IFCR_CTCIF7_SHIFT (25) +#define DMA_IFCR_CTCIF7_MASK (0x01U << DMA_IFCR_CTCIF7_SHIFT) +#define DMA_IFCR_CTCIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTCIF7_SHIFT)) & DMA_IFCR_CTCIF7_MASK) + +#define DMA_IFCR_CGIF7_SHIFT (24) +#define DMA_IFCR_CGIF7_MASK (0x01U << DMA_IFCR_CGIF7_SHIFT) +#define DMA_IFCR_CGIF7(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CGIF7_SHIFT)) & DMA_IFCR_CGIF7_MASK) + +#define DMA_IFCR_CTEIF6_SHIFT (23) +#define DMA_IFCR_CTEIF6_MASK (0x01U << DMA_IFCR_CTEIF6_SHIFT) +#define DMA_IFCR_CTEIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTEIF6_SHIFT)) & DMA_IFCR_CTEIF6_MASK) + +#define DMA_IFCR_CHTIF6_SHIFT (22) +#define DMA_IFCR_CHTIF6_MASK (0x01U << DMA_IFCR_CHTIF6_SHIFT) +#define DMA_IFCR_CHTIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CHTIF6_SHIFT)) & DMA_IFCR_CHTIF6_MASK) + +#define DMA_IFCR_CTCIF6_SHIFT (21) +#define DMA_IFCR_CTCIF6_MASK (0x01U << DMA_IFCR_CTCIF6_SHIFT) +#define DMA_IFCR_CTCIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTCIF6_SHIFT)) & DMA_IFCR_CTCIF6_MASK) + +#define DMA_IFCR_CGIF6_SHIFT (20) +#define DMA_IFCR_CGIF6_MASK (0x01U << DMA_IFCR_CGIF6_SHIFT) +#define DMA_IFCR_CGIF6(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CGIF6_SHIFT)) & DMA_IFCR_CGIF6_MASK) + +#define DMA_IFCR_CTEIF5_SHIFT (19) +#define DMA_IFCR_CTEIF5_MASK (0x01U << DMA_IFCR_CTEIF5_SHIFT) +#define DMA_IFCR_CTEIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTEIF5_SHIFT)) & DMA_IFCR_CTEIF5_MASK) + +#define DMA_IFCR_CHTIF5_SHIFT (18) +#define DMA_IFCR_CHTIF5_MASK (0x01U << DMA_IFCR_CHTIF5_SHIFT) +#define DMA_IFCR_CHTIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CHTIF5_SHIFT)) & DMA_IFCR_CHTIF5_MASK) + +#define DMA_IFCR_CTCIF5_SHIFT (17) +#define DMA_IFCR_CTCIF5_MASK (0x01U << DMA_IFCR_CTCIF5_SHIFT) +#define DMA_IFCR_CTCIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTCIF5_SHIFT)) & DMA_IFCR_CTCIF5_MASK) + +#define DMA_IFCR_CGIF5_SHIFT (16) +#define DMA_IFCR_CGIF5_MASK (0x01U << DMA_IFCR_CGIF5_SHIFT) +#define DMA_IFCR_CGIF5(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CGIF5_SHIFT)) & DMA_IFCR_CGIF5_MASK) + +#define DMA_IFCR_CTEIF4_SHIFT (15) +#define DMA_IFCR_CTEIF4_MASK (0x01U << DMA_IFCR_CTEIF4_SHIFT) +#define DMA_IFCR_CTEIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTEIF4_SHIFT)) & DMA_IFCR_CTEIF4_MASK) + +#define DMA_IFCR_CHTIF4_SHIFT (14) +#define DMA_IFCR_CHTIF4_MASK (0x01U << DMA_IFCR_CHTIF4_SHIFT) +#define DMA_IFCR_CHTIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CHTIF4_SHIFT)) & DMA_IFCR_CHTIF4_MASK) + +#define DMA_IFCR_CTCIF4_SHIFT (13) +#define DMA_IFCR_CTCIF4_MASK (0x01U << DMA_IFCR_CTCIF4_SHIFT) +#define DMA_IFCR_CTCIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTCIF4_SHIFT)) & DMA_IFCR_CTCIF4_MASK) + +#define DMA_IFCR_CGIF4_SHIFT (12) +#define DMA_IFCR_CGIF4_MASK (0x01U << DMA_IFCR_CGIF4_SHIFT) +#define DMA_IFCR_CGIF4(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CGIF4_SHIFT)) & DMA_IFCR_CGIF4_MASK) + +#define DMA_IFCR_CTEIF3_SHIFT (11) +#define DMA_IFCR_CTEIF3_MASK (0x01U << DMA_IFCR_CTEIF3_SHIFT) +#define DMA_IFCR_CTEIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTEIF3_SHIFT)) & DMA_IFCR_CTEIF3_MASK) + +#define DMA_IFCR_CHTIF3_SHIFT (10) +#define DMA_IFCR_CHTIF3_MASK (0x01U << DMA_IFCR_CHTIF3_SHIFT) +#define DMA_IFCR_CHTIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CHTIF3_SHIFT)) & DMA_IFCR_CHTIF3_MASK) + +#define DMA_IFCR_CTCIF3_SHIFT (9) +#define DMA_IFCR_CTCIF3_MASK (0x01U << DMA_IFCR_CTCIF3_SHIFT) +#define DMA_IFCR_CTCIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTCIF3_SHIFT)) & DMA_IFCR_CTCIF3_MASK) + +#define DMA_IFCR_CGIF3_SHIFT (8) +#define DMA_IFCR_CGIF3_MASK (0x01U << DMA_IFCR_CGIF3_SHIFT) +#define DMA_IFCR_CGIF3(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CGIF3_SHIFT)) & DMA_IFCR_CGIF3_MASK) + +#define DMA_IFCR_CTEIF2_SHIFT (7) +#define DMA_IFCR_CTEIF2_MASK (0x01U << DMA_IFCR_CTEIF2_SHIFT) +#define DMA_IFCR_CTEIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTEIF2_SHIFT)) & DMA_IFCR_CTEIF2_MASK) + +#define DMA_IFCR_CHTIF2_SHIFT (6) +#define DMA_IFCR_CHTIF2_MASK (0x01U << DMA_IFCR_CHTIF2_SHIFT) +#define DMA_IFCR_CHTIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CHTIF2_SHIFT)) & DMA_IFCR_CHTIF2_MASK) + +#define DMA_IFCR_CTCIF2_SHIFT (5) +#define DMA_IFCR_CTCIF2_MASK (0x01U << DMA_IFCR_CTCIF2_SHIFT) +#define DMA_IFCR_CTCIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTCIF2_SHIFT)) & DMA_IFCR_CTCIF2_MASK) + +#define DMA_IFCR_CGIF2_SHIFT (4) +#define DMA_IFCR_CGIF2_MASK (0x01U << DMA_IFCR_CGIF2_SHIFT) +#define DMA_IFCR_CGIF2(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CGIF2_SHIFT)) & DMA_IFCR_CGIF2_MASK) + +#define DMA_IFCR_CTEIF1_SHIFT (3) +#define DMA_IFCR_CTEIF1_MASK (0x01U << DMA_IFCR_CTEIF1_SHIFT) +#define DMA_IFCR_CTEIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTEIF1_SHIFT)) & DMA_IFCR_CTEIF1_MASK) + +#define DMA_IFCR_CHTIF1_SHIFT (2) +#define DMA_IFCR_CHTIF1_MASK (0x01U << DMA_IFCR_CHTIF1_SHIFT) +#define DMA_IFCR_CHTIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CHTIF1_SHIFT)) & DMA_IFCR_CHTIF1_MASK) + +#define DMA_IFCR_CTCIF1_SHIFT (1) +#define DMA_IFCR_CTCIF1_MASK (0x01U << DMA_IFCR_CTCIF1_SHIFT) +#define DMA_IFCR_CTCIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CTCIF1_SHIFT)) & DMA_IFCR_CTCIF1_MASK) + +#define DMA_IFCR_CGIF1_SHIFT (0) +#define DMA_IFCR_CGIF1_MASK (0x01U << DMA_IFCR_CGIF1_SHIFT) +#define DMA_IFCR_CGIF1(x) (((uint32_t)(((uint32_t)(x)) << DMA_IFCR_CGIF1_SHIFT)) & DMA_IFCR_CGIF1_MASK) + +/*! + * @brief DMA_CCR Register Bit Definition + */ + +#define DMA_CCR_ARE_SHIFT (15) +#define DMA_CCR_ARE_MASK (0x01U << DMA_CCR_ARE_SHIFT) +#define DMA_CCR_ARE(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_ARE_SHIFT)) & DMA_CCR_ARE_MASK) + +#define DMA_CCR_MEM2MEM_SHIFT (14) +#define DMA_CCR_MEM2MEM_MASK (0x01U << DMA_CCR_MEM2MEM_SHIFT) +#define DMA_CCR_MEM2MEM(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_MEM2MEM_SHIFT)) & DMA_CCR_MEM2MEM_MASK) + +#define DMA_CCR_PL_SHIFT (12) +#define DMA_CCR_PL_MASK (0x3U << DMA_CCR_PL_SHIFT) +#define DMA_CCR_PL(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_PL_SHIFT)) & DMA_CCR_PL_MASK) + +#define DMA_CCR_MSIZE_SHIFT (10) +#define DMA_CCR_MSIZE_MASK (0x3U << DMA_CCR_MSIZE_SHIFT) +#define DMA_CCR_MSIZE(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_MSIZE_SHIFT)) & DMA_CCR_MSIZE_MASK) + +#define DMA_CCR_PSIZE_SHIFT (8) +#define DMA_CCR_PSIZE_MASK (0x3U << DMA_CCR_PSIZE_SHIFT) +#define DMA_CCR_PSIZE(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_PSIZE_SHIFT)) & DMA_CCR_PSIZE_MASK) + +#define DMA_CCR_MINC_SHIFT (7) +#define DMA_CCR_MINC_MASK (0x01U << DMA_CCR_MINC_SHIFT) +#define DMA_CCR_MINC(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_MINC_SHIFT)) & DMA_CCR_MINC_MASK) + +#define DMA_CCR_PINC_SHIFT (6) +#define DMA_CCR_PINC_MASK (0x01U << DMA_CCR_PINC_SHIFT) +#define DMA_CCR_PINC(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_PINC_SHIFT)) & DMA_CCR_PINC_MASK) + +#define DMA_CCR_CIRC_SHIFT (5) +#define DMA_CCR_CIRC_MASK (0x01U << DMA_CCR_CIRC_SHIFT) +#define DMA_CCR_CIRC(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_CIRC_SHIFT)) & DMA_CCR_CIRC_MASK) + +#define DMA_CCR_DIR_SHIFT (4) +#define DMA_CCR_DIR_MASK (0x01U << DMA_CCR_DIR_SHIFT) +#define DMA_CCR_DIR(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_DIR_SHIFT)) & DMA_CCR_DIR_MASK) + +#define DMA_CCR_TEIE_SHIFT (3) +#define DMA_CCR_TEIE_MASK (0x01U << DMA_CCR_TEIE_SHIFT) +#define DMA_CCR_TEIE(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_TEIE_SHIFT)) & DMA_CCR_TEIE_MASK) + +#define DMA_CCR_HTIE_SHIFT (2) +#define DMA_CCR_HTIE_MASK (0x01U << DMA_CCR_HTIE_SHIFT) +#define DMA_CCR_HTIE(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_HTIE_SHIFT)) & DMA_CCR_HTIE_MASK) + +#define DMA_CCR_TCIE_SHIFT (1) +#define DMA_CCR_TCIE_MASK (0x01U << DMA_CCR_TCIE_SHIFT) +#define DMA_CCR_TCIE(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_TCIE_SHIFT)) & DMA_CCR_TCIE_MASK) + +#define DMA_CCR_EN_SHIFT (0) +#define DMA_CCR_EN_MASK (0x01U << DMA_CCR_EN_SHIFT) +#define DMA_CCR_EN(x) (((uint32_t)(((uint32_t)(x)) << DMA_CCR_EN_SHIFT)) & DMA_CCR_EN_MASK) + +/*! + * @brief DMA_CNDTR Register Bit Definition + */ + +#define DMA_CNDTR_NDT_SHIFT (0) +#define DMA_CNDTR_NDT_MASK (0xFFFFU << DMA_CNDTR_NDT_SHIFT) +#define DMA_CNDTR_NDT(x) (((uint32_t)(((uint32_t)(x)) << DMA_CNDTR_NDT_SHIFT)) & DMA_CNDTR_NDT_MASK) + +/*! + * @brief DMA_CPAR Register Bit Definition + */ + +#define DMA_CPAR_PA_SHIFT (0) +#define DMA_CPAR_PA_MASK (0xFFFFFFFFU << DMA_CPAR_PA_SHIFT) +#define DMA_CPAR_PA(x) (((uint32_t)(((uint32_t)(x)) << DMA_CPAR_PA_SHIFT)) & DMA_CPAR_PA_MASK) + +/*! + * @brief DMA_CMAR Register Bit Definition + */ + +#define DMA_CMAR_MA_SHIFT (0) +#define DMA_CMAR_MA_MASK (0xFFFFFFFFU << DMA_CMAR_MA_SHIFT) +#define DMA_CMAR_MA(x) (((uint32_t)(((uint32_t)(x)) << DMA_CMAR_MA_SHIFT)) & DMA_CMAR_MA_MASK) + +/*! + * @} + */ /* end of group DMA_Register_Masks */ +/****************************************************************************** + * DMA Instance +******************************************************************************/ +#define DMA1 ((DMA_Type*)DMA1_BASE) +#define DMA2 ((DMA_Type*)DMA2_BASE) + +/*! + * @} + */ /* end of group DMA_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup BKP_Peripheral_Access_Layer BKP Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * BKP Type + ******************************************************************************/ +typedef struct { + __IO uint32_t Reserved5[16]; ///< Reserved + __IO uint32_t RTCCR; ///< RTC clock calibration register offset: 0x40 + __IO uint32_t CR; ///< Backup control register offset: 0x44 + __IO uint32_t CSR; ///< Backup control status register offset: 0x48 + __IO uint32_t Reserved6[1]; ///< Reserved + __IO uint32_t DR[20]; ///< Backup data register x offset: 0x50 +} BKP_Type; + +/******************************************************************************* + * BKP Type + ******************************************************************************/ + +/*! + * @addtogroup BKP_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief BKP_RTCCR Register Bit Definition + */ + +#define BKP_RTCCR_ASOS_SHIFT (9) +#define BKP_RTCCR_ASOS_MASK (0x01U << BKP_RTCCR_ASOS_SHIFT) +#define BKP_RTCCR_ASOS(x) (((uint32_t)(((uint32_t)(x)) << BKP_RTCCR_ASOS_SHIFT)) & BKP_RTCCR_ASOS_MASK) + +#define BKP_RTCCR_ASOE_SHIFT (8) +#define BKP_RTCCR_ASOE_MASK (0x01U << BKP_RTCCR_ASOE_SHIFT) +#define BKP_RTCCR_ASOE(x) (((uint32_t)(((uint32_t)(x)) << BKP_RTCCR_ASOE_SHIFT)) & BKP_RTCCR_ASOE_MASK) + +#define BKP_RTCCR_CCO_SHIFT (7) +#define BKP_RTCCR_CCO_MASK (0x01U << BKP_RTCCR_CCO_SHIFT) +#define BKP_RTCCR_CCO(x) (((uint32_t)(((uint32_t)(x)) << BKP_RTCCR_CCO_SHIFT)) & BKP_RTCCR_CCO_MASK) + +#define BKP_RTCCR_CAL_SHIFT (0) +#define BKP_RTCCR_CAL_MASK (0x7FU << BKP_RTCCR_CAL_SHIFT) +#define BKP_RTCCR_CAL(x) (((uint32_t)(((uint32_t)(x)) << BKP_RTCCR_CAL_SHIFT)) & BKP_RTCCR_CAL_MASK) + +/*! + * @brief BKP_CR Register Bit Definition + */ + +#define BKP_CR_TPAL_SHIFT (1) +#define BKP_CR_TPAL_MASK (0x01U << BKP_CR_TPAL_SHIFT) +#define BKP_CR_TPAL(x) (((uint32_t)(((uint32_t)(x)) << BKP_CR_TPAL_SHIFT)) & BKP_CR_TPAL_MASK) + +#define BKP_CR_TPE_SHIFT (0) +#define BKP_CR_TPE_MASK (0x01U << BKP_CR_TPE_SHIFT) +#define BKP_CR_TPE(x) (((uint32_t)(((uint32_t)(x)) << BKP_CR_TPE_SHIFT)) & BKP_CR_TPE_MASK) + +/*! + * @brief BKP_CSR Register Bit Definition + */ + +#define BKP_CSR_TIF_SHIFT (9) +#define BKP_CSR_TIF_MASK (0x01U << BKP_CSR_TIF_SHIFT) +#define BKP_CSR_TIF(x) (((uint32_t)(((uint32_t)(x)) << BKP_CSR_TIF_SHIFT)) & BKP_CSR_TIF_MASK) + +#define BKP_CSR_TEF_SHIFT (8) +#define BKP_CSR_TEF_MASK (0x01U << BKP_CSR_TEF_SHIFT) +#define BKP_CSR_TEF(x) (((uint32_t)(((uint32_t)(x)) << BKP_CSR_TEF_SHIFT)) & BKP_CSR_TEF_MASK) + +#define BKP_CSR_TPIE_SHIFT (2) +#define BKP_CSR_TPIE_MASK (0x01U << BKP_CSR_TPIE_SHIFT) +#define BKP_CSR_TPIE(x) (((uint32_t)(((uint32_t)(x)) << BKP_CSR_TPIE_SHIFT)) & BKP_CSR_TPIE_MASK) + +#define BKP_CSR_CTI_SHIFT (1) +#define BKP_CSR_CTI_MASK (0x01U << BKP_CSR_CTI_SHIFT) +#define BKP_CSR_CTI(x) (((uint32_t)(((uint32_t)(x)) << BKP_CSR_CTI_SHIFT)) & BKP_CSR_CTI_MASK) + +#define BKP_CSR_CTE_SHIFT (0) +#define BKP_CSR_CTE_MASK (0x01U << BKP_CSR_CTE_SHIFT) +#define BKP_CSR_CTE(x) (((uint32_t)(((uint32_t)(x)) << BKP_CSR_CTE_SHIFT)) & BKP_CSR_CTE_MASK) + +/*! + * @brief BKP_DR Register Bit Definition + */ + +#define BKP_DR_BKP_SHIFT (0) +#define BKP_DR_BKP_MASK (0xFFFFU << BKP_DR_BKP_SHIFT) +#define BKP_DR_BKP(x) (((uint32_t)(((uint32_t)(x)) << BKP_DR_BKP_SHIFT)) & BKP_DR_BKP_MASK) + +/*! + * @} + */ /* end of group BKP_Register_Masks */ +/****************************************************************************** + * BKP Instance +******************************************************************************/ +#define BKP ((BKP_Type*)RTC_BKP_BASE) + +/*! + * @} + */ /* end of group BKP_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup CRS_Peripheral_Access_Layer CRS Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * CRS Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR; ///< CRS control register offset: 0x00 + __IO uint32_t CFGR; ///< CRS configuration register offset: 0x04 + __IO uint32_t lSR; ///< CRS interrupt status register offset: 0x08 + __IO uint32_t lCR; ///< CRS interrupt flag clear register offset: 0x0C +} CRS_Type; + +/******************************************************************************* + * CRS Type + ******************************************************************************/ + +/*! + * @addtogroup CRS_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief CRS_CR Register Bit Definition + */ + +#define CRS_CR_TRIM_SHIFT (8) +#define CRS_CR_TRIM_MASK (0x3FFU << CRS_CR_TRIM_SHIFT) +#define CRS_CR_TRIM(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_TRIM_SHIFT)) & CRS_CR_TRIM_MASK) + +#define CRS_CR_SWSYNC_SHIFT (7) +#define CRS_CR_SWSYNC_MASK (0x01U << CRS_CR_SWSYNC_SHIFT) +#define CRS_CR_SWSYNC(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_SWSYNC_SHIFT)) & CRS_CR_SWSYNC_MASK) + +#define CRS_CR_AUTOTRIMEN_SHIFT (6) +#define CRS_CR_AUTOTRIMEN_MASK (0x01U << CRS_CR_AUTOTRIMEN_SHIFT) +#define CRS_CR_AUTOTRIMEN(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_AUTOTRIMEN_SHIFT)) & CRS_CR_AUTOTRIMEN_MASK) + +#define CRS_CR_CEN_SHIFT (5) +#define CRS_CR_CEN_MASK (0x01U << CRS_CR_CEN_SHIFT) +#define CRS_CR_CEN(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_CEN_SHIFT)) & CRS_CR_CEN_MASK) + +#define CRS_CR_ESYNCIE_SHIFT (3) +#define CRS_CR_ESYNCIE_MASK (0x01U << CRS_CR_ESYNCIE_SHIFT) +#define CRS_CR_ESYNCIE(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_ESYNCIE_SHIFT)) & CRS_CR_ESYNCIE_MASK) + +#define CRS_CR_ERRIE_SHIFT (2) +#define CRS_CR_ERRIE_MASK (0x01U << CRS_CR_ERRIE_SHIFT) +#define CRS_CR_ERRIE(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_ERRIE_SHIFT)) & CRS_CR_ERRIE_MASK) + +#define CRS_CR_SYNCWARNIE_SHIFT (1) +#define CRS_CR_SYNCWARNIE_MASK (0x01U << CRS_CR_SYNCWARNIE_SHIFT) +#define CRS_CR_SYNCWARNIE(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_SYNCWARNIE_SHIFT)) & CRS_CR_SYNCWARNIE_MASK) + +#define CRS_CR_SYNCOKIE_SHIFT (0) +#define CRS_CR_SYNCOKIE_MASK (0x01U << CRS_CR_SYNCOKIE_SHIFT) +#define CRS_CR_SYNCOKIE(x) (((uint32_t)(((uint32_t)(x)) << CRS_CR_SYNCOKIE_SHIFT)) & CRS_CR_SYNCOKIE_MASK) + +/*! + * @brief CRS_CFGR Register Bit Definition + */ + +#define CRS_CFGR_SYNCPOL_SHIFT (31) +#define CRS_CFGR_SYNCPOL_MASK (0x01U << CRS_CFGR_SYNCPOL_SHIFT) +#define CRS_CFGR_SYNCPOL(x) (((uint32_t)(((uint32_t)(x)) << CRS_CFGR_SYNCPOL_SHIFT)) & CRS_CFGR_SYNCPOL_MASK) + +#define CRS_CFGR_SYNCSRC_SHIFT (28) +#define CRS_CFGR_SYNCSRC_MASK (0x3U << CRS_CFGR_SYNCSRC_SHIFT) +#define CRS_CFGR_SYNCSRC(x) (((uint32_t)(((uint32_t)(x)) << CRS_CFGR_SYNCSRC_SHIFT)) & CRS_CFGR_SYNCSRC_MASK) + +#define CRS_CFGR_SYNCDIV_SHIFT (24) +#define CRS_CFGR_SYNCDIV_MASK (0x7U << CRS_CFGR_SYNCDIV_SHIFT) +#define CRS_CFGR_SYNCDIV(x) (((uint32_t)(((uint32_t)(x)) << CRS_CFGR_SYNCDIV_SHIFT)) & CRS_CFGR_SYNCDIV_MASK) + +#define CRS_CFGR_FELIM_SHIFT (16) +#define CRS_CFGR_FELIM_MASK (0xFFU << CRS_CFGR_FELIM_SHIFT) +#define CRS_CFGR_FELIM(x) (((uint32_t)(((uint32_t)(x)) << CRS_CFGR_FELIM_SHIFT)) & CRS_CFGR_FELIM_MASK) + +#define CRS_CFGR_RELOAD_SHIFT (0) +#define CRS_CFGR_RELOAD_MASK (0xFFFFU << CRS_CFGR_RELOAD_SHIFT) +#define CRS_CFGR_RELOAD(x) (((uint32_t)(((uint32_t)(x)) << CRS_CFGR_RELOAD_SHIFT)) & CRS_CFGR_RELOAD_MASK) + +/*! + * @brief CRS_lSR Register Bit Definition + */ + +#define CRS_lSR_FECAP_SHIFT (16) +#define CRS_lSR_FECAP_MASK (0xFFFFU << CRS_lSR_FECAP_SHIFT) +#define CRS_lSR_FECAP(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_FECAP_SHIFT)) & CRS_lSR_FECAP_MASK) + +#define CRS_lSR_FEDIR_SHIFT (15) +#define CRS_lSR_FEDIR_MASK (0x01U << CRS_lSR_FEDIR_SHIFT) +#define CRS_lSR_FEDIR(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_FEDIR_SHIFT)) & CRS_lSR_FEDIR_MASK) + +#define CRS_lSR_TRIMOVF_SHIFT (10) +#define CRS_lSR_TRIMOVF_MASK (0x01U << CRS_lSR_TRIMOVF_SHIFT) +#define CRS_lSR_TRIMOVF(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_TRIMOVF_SHIFT)) & CRS_lSR_TRIMOVF_MASK) + +#define CRS_lSR_SYNCMISS_SHIFT (9) +#define CRS_lSR_SYNCMISS_MASK (0x01U << CRS_lSR_SYNCMISS_SHIFT) +#define CRS_lSR_SYNCMISS(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_SYNCMISS_SHIFT)) & CRS_lSR_SYNCMISS_MASK) + +#define CRS_lSR_SYNCERR_SHIFT (8) +#define CRS_lSR_SYNCERR_MASK (0x01U << CRS_lSR_SYNCERR_SHIFT) +#define CRS_lSR_SYNCERR(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_SYNCERR_SHIFT)) & CRS_lSR_SYNCERR_MASK) + +#define CRS_lSR_ESYNCF_SHIFT (3) +#define CRS_lSR_ESYNCF_MASK (0x01U << CRS_lSR_ESYNCF_SHIFT) +#define CRS_lSR_ESYNCF(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_ESYNCF_SHIFT)) & CRS_lSR_ESYNCF_MASK) + +#define CRS_lSR_ERRF_SHIFT (2) +#define CRS_lSR_ERRF_MASK (0x01U << CRS_lSR_ERRF_SHIFT) +#define CRS_lSR_ERRF(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_ERRF_SHIFT)) & CRS_lSR_ERRF_MASK) + +#define CRS_lSR_SYNCWARNF_SHIFT (1) +#define CRS_lSR_SYNCWARNF_MASK (0x01U << CRS_lSR_SYNCWARNF_SHIFT) +#define CRS_lSR_SYNCWARNF(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_SYNCWARNF_SHIFT)) & CRS_lSR_SYNCWARNF_MASK) + +#define CRS_lSR_SYNCOKF_SHIFT (0) +#define CRS_lSR_SYNCOKF_MASK (0x01U << CRS_lSR_SYNCOKF_SHIFT) +#define CRS_lSR_SYNCOKF(x) (((uint32_t)(((uint32_t)(x)) << CRS_lSR_SYNCOKF_SHIFT)) & CRS_lSR_SYNCOKF_MASK) + +/*! + * @brief CRS_lCR Register Bit Definition + */ + +#define CRS_lCR_ESYNCC_SHIFT (3) +#define CRS_lCR_ESYNCC_MASK (0x01U << CRS_lCR_ESYNCC_SHIFT) +#define CRS_lCR_ESYNCC(x) (((uint32_t)(((uint32_t)(x)) << CRS_lCR_ESYNCC_SHIFT)) & CRS_lCR_ESYNCC_MASK) + +#define CRS_lCR_ERRC_SHIFT (2) +#define CRS_lCR_ERRC_MASK (0x01U << CRS_lCR_ERRC_SHIFT) +#define CRS_lCR_ERRC(x) (((uint32_t)(((uint32_t)(x)) << CRS_lCR_ERRC_SHIFT)) & CRS_lCR_ERRC_MASK) + +#define CRS_lCR_SYNCWARNC_SHIFT (1) +#define CRS_lCR_SYNCWARNC_MASK (0x01U << CRS_lCR_SYNCWARNC_SHIFT) +#define CRS_lCR_SYNCWARNC(x) (((uint32_t)(((uint32_t)(x)) << CRS_lCR_SYNCWARNC_SHIFT)) & CRS_lCR_SYNCWARNC_MASK) + +#define CRS_lCR_SYNCOKC_SHIFT (0) +#define CRS_lCR_SYNCOKC_MASK (0x01U << CRS_lCR_SYNCOKC_SHIFT) +#define CRS_lCR_SYNCOKC(x) (((uint32_t)(((uint32_t)(x)) << CRS_lCR_SYNCOKC_SHIFT)) & CRS_lCR_SYNCOKC_MASK) + +/*! + * @} + */ /* end of group CRS_Register_Masks */ +/****************************************************************************** + * CRS Instance +******************************************************************************/ +#define CRS ((CRS_Type*)CRS_BASE) + +/*! + * @} + */ /* end of group CRS_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup GPIO_Peripheral_Access_Layer GPIO Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * GPIO Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CRL; ///< Port configuration low register offset: 0x00 + __IO uint32_t CRH; ///< Port configuration high register offset: 0x04 + __IO uint32_t IDR; ///< Port input data register offset: 0x08 + __IO uint32_t ODR; ///< Port output data register offset: 0x0C + __IO uint32_t BSRR; ///< Port set/clear register offset: 0x10 + __IO uint32_t BRR; ///< Port bit clear register offset: 0x14 + __IO uint32_t LCKR; ///< Port configuration lock register offset: 0x18 + __IO uint32_t DCR; ///< Port output open drain control register offset: 0x1C + __IO uint32_t AFRL; ///< Port multiplexing function low register offset: 0x20 + __IO uint32_t AFRH; ///< Port multiplexing function high register offset: 0x24 +} GPIO_Type; + +/******************************************************************************* + * GPIO Type + ******************************************************************************/ + +/*! + * @addtogroup GPIO_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief GPIO_CRL Register Bit Definition + */ + +#define GPIO_CRL_CNF7_SHIFT (30) +#define GPIO_CRL_CNF7_MASK (0x3U << GPIO_CRL_CNF7_SHIFT) +#define GPIO_CRL_CNF7(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF7_SHIFT)) & GPIO_CRL_CNF7_MASK) + +#define GPIO_CRL_CNF6_SHIFT (26) +#define GPIO_CRL_CNF6_MASK (0x3U << GPIO_CRL_CNF6_SHIFT) +#define GPIO_CRL_CNF6(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF6_SHIFT)) & GPIO_CRL_CNF6_MASK) + +#define GPIO_CRL_CNF5_SHIFT (22) +#define GPIO_CRL_CNF5_MASK (0x3U << GPIO_CRL_CNF5_SHIFT) +#define GPIO_CRL_CNF5(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF5_SHIFT)) & GPIO_CRL_CNF5_MASK) + +#define GPIO_CRL_CNF4_SHIFT (18) +#define GPIO_CRL_CNF4_MASK (0x3U << GPIO_CRL_CNF4_SHIFT) +#define GPIO_CRL_CNF4(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF4_SHIFT)) & GPIO_CRL_CNF4_MASK) + +#define GPIO_CRL_CNF3_SHIFT (14) +#define GPIO_CRL_CNF3_MASK (0x3U << GPIO_CRL_CNF3_SHIFT) +#define GPIO_CRL_CNF3(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF3_SHIFT)) & GPIO_CRL_CNF3_MASK) + +#define GPIO_CRL_CNF2_SHIFT (10) +#define GPIO_CRL_CNF2_MASK (0x3U << GPIO_CRL_CNF2_SHIFT) +#define GPIO_CRL_CNF2(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF2_SHIFT)) & GPIO_CRL_CNF2_MASK) + +#define GPIO_CRL_CNF1_SHIFT (6) +#define GPIO_CRL_CNF1_MASK (0x3U << GPIO_CRL_CNF1_SHIFT) +#define GPIO_CRL_CNF1(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF1_SHIFT)) & GPIO_CRL_CNF1_MASK) + +#define GPIO_CRL_CNF0_SHIFT (2) +#define GPIO_CRL_CNF0_MASK (0x3U << GPIO_CRL_CNF0_SHIFT) +#define GPIO_CRL_CNF0(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_CNF0_SHIFT)) & GPIO_CRL_CNF0_MASK) + +#define GPIO_CRL_MODE7_SHIFT (28) +#define GPIO_CRL_MODE7_MASK (0x3U << GPIO_CRL_MODE7_SHIFT) +#define GPIO_CRL_MODE7(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE7_SHIFT)) & GPIO_CRL_MODE7_MASK) + +#define GPIO_CRL_MODE6_SHIFT (24) +#define GPIO_CRL_MODE6_MASK (0x3U << GPIO_CRL_MODE6_SHIFT) +#define GPIO_CRL_MODE6(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE6_SHIFT)) & GPIO_CRL_MODE6_MASK) + +#define GPIO_CRL_MODE5_SHIFT (20) +#define GPIO_CRL_MODE5_MASK (0x3U << GPIO_CRL_MODE5_SHIFT) +#define GPIO_CRL_MODE5(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE5_SHIFT)) & GPIO_CRL_MODE5_MASK) + +#define GPIO_CRL_MODE4_SHIFT (16) +#define GPIO_CRL_MODE4_MASK (0x3U << GPIO_CRL_MODE4_SHIFT) +#define GPIO_CRL_MODE4(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE4_SHIFT)) & GPIO_CRL_MODE4_MASK) + +#define GPIO_CRL_MODE3_SHIFT (12) +#define GPIO_CRL_MODE3_MASK (0x3U << GPIO_CRL_MODE3_SHIFT) +#define GPIO_CRL_MODE3(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE3_SHIFT)) & GPIO_CRL_MODE3_MASK) + +#define GPIO_CRL_MODE2_SHIFT (8) +#define GPIO_CRL_MODE2_MASK (0x3U << GPIO_CRL_MODE2_SHIFT) +#define GPIO_CRL_MODE2(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE2_SHIFT)) & GPIO_CRL_MODE2_MASK) + +#define GPIO_CRL_MODE1_SHIFT (4) +#define GPIO_CRL_MODE1_MASK (0x3U << GPIO_CRL_MODE1_SHIFT) +#define GPIO_CRL_MODE1(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE1_SHIFT)) & GPIO_CRL_MODE1_MASK) + +#define GPIO_CRL_MODE0_SHIFT (0) +#define GPIO_CRL_MODE0_MASK (0x3U << GPIO_CRL_MODE0_SHIFT) +#define GPIO_CRL_MODE0(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRL_MODE0_SHIFT)) & GPIO_CRL_MODE0_MASK) + +/*! + * @brief GPIO_CRH Register Bit Definition + */ + +#define GPIO_CRH_CNF15_SHIFT (30) +#define GPIO_CRH_CNF15_MASK (0x3U << GPIO_CRH_CNF15_SHIFT) +#define GPIO_CRH_CNF15(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF15_SHIFT)) & GPIO_CRH_CNF15_MASK) + +#define GPIO_CRH_CNF14_SHIFT (26) +#define GPIO_CRH_CNF14_MASK (0x3U << GPIO_CRH_CNF14_SHIFT) +#define GPIO_CRH_CNF14(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF14_SHIFT)) & GPIO_CRH_CNF14_MASK) + +#define GPIO_CRH_CNF13_SHIFT (22) +#define GPIO_CRH_CNF13_MASK (0x3U << GPIO_CRH_CNF13_SHIFT) +#define GPIO_CRH_CNF13(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF13_SHIFT)) & GPIO_CRH_CNF13_MASK) + +#define GPIO_CRH_CNF12_SHIFT (18) +#define GPIO_CRH_CNF12_MASK (0x3U << GPIO_CRH_CNF12_SHIFT) +#define GPIO_CRH_CNF12(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF12_SHIFT)) & GPIO_CRH_CNF12_MASK) + +#define GPIO_CRH_CNF11_SHIFT (14) +#define GPIO_CRH_CNF11_MASK (0x3U << GPIO_CRH_CNF11_SHIFT) +#define GPIO_CRH_CNF11(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF11_SHIFT)) & GPIO_CRH_CNF11_MASK) + +#define GPIO_CRH_CNF10_SHIFT (10) +#define GPIO_CRH_CNF10_MASK (0x3U << GPIO_CRH_CNF10_SHIFT) +#define GPIO_CRH_CNF10(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF10_SHIFT)) & GPIO_CRH_CNF10_MASK) + +#define GPIO_CRH_CNF9_SHIFT (6) +#define GPIO_CRH_CNF9_MASK (0x3U << GPIO_CRH_CNF9_SHIFT) +#define GPIO_CRH_CNF9(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF9_SHIFT)) & GPIO_CRH_CNF9_MASK) + +#define GPIO_CRH_CNF8_SHIFT (2) +#define GPIO_CRH_CNF8_MASK (0x3U << GPIO_CRH_CNF8_SHIFT) +#define GPIO_CRH_CNF8(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_CNF8_SHIFT)) & GPIO_CRH_CNF8_MASK) + +#define GPIO_CRH_MODE15_SHIFT (28) +#define GPIO_CRH_MODE15_MASK (0x3U << GPIO_CRH_MODE15_SHIFT) +#define GPIO_CRH_MODE15(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE15_SHIFT)) & GPIO_CRH_MODE15_MASK) + +#define GPIO_CRH_MODE14_SHIFT (24) +#define GPIO_CRH_MODE14_MASK (0x3U << GPIO_CRH_MODE14_SHIFT) +#define GPIO_CRH_MODE14(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE14_SHIFT)) & GPIO_CRH_MODE14_MASK) + +#define GPIO_CRH_MODE13_SHIFT (20) +#define GPIO_CRH_MODE13_MASK (0x3U << GPIO_CRH_MODE13_SHIFT) +#define GPIO_CRH_MODE13(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE13_SHIFT)) & GPIO_CRH_MODE13_MASK) + +#define GPIO_CRH_MODE12_SHIFT (16) +#define GPIO_CRH_MODE12_MASK (0x3U << GPIO_CRH_MODE12_SHIFT) +#define GPIO_CRH_MODE12(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE12_SHIFT)) & GPIO_CRH_MODE12_MASK) + +#define GPIO_CRH_MODE11_SHIFT (12) +#define GPIO_CRH_MODE11_MASK (0x3U << GPIO_CRH_MODE11_SHIFT) +#define GPIO_CRH_MODE11(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE11_SHIFT)) & GPIO_CRH_MODE11_MASK) + +#define GPIO_CRH_MODE10_SHIFT (8) +#define GPIO_CRH_MODE10_MASK (0x3U << GPIO_CRH_MODE10_SHIFT) +#define GPIO_CRH_MODE10(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE10_SHIFT)) & GPIO_CRH_MODE10_MASK) + +#define GPIO_CRH_MODE9_SHIFT (4) +#define GPIO_CRH_MODE9_MASK (0x3U << GPIO_CRH_MODE9_SHIFT) +#define GPIO_CRH_MODE9(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE9_SHIFT)) & GPIO_CRH_MODE9_MASK) + +#define GPIO_CRH_MODE8_SHIFT (0) +#define GPIO_CRH_MODE8_MASK (0x3U << GPIO_CRH_MODE8_SHIFT) +#define GPIO_CRH_MODE8(x) (((uint32_t)(((uint32_t)(x)) << GPIO_CRH_MODE8_SHIFT)) & GPIO_CRH_MODE8_MASK) + +/*! + * @brief GPIO_IDR Register Bit Definition + */ + +#define GPIO_IDR_IDRy_SHIFT (0) +#define GPIO_IDR_IDRy_MASK (0xFFFFU << GPIO_IDR_IDRy_SHIFT) +#define GPIO_IDR_IDRy(x) (((uint32_t)(((uint32_t)(x)) << GPIO_IDR_IDRy_SHIFT)) & GPIO_IDR_IDRy_MASK) + +/*! + * @brief GPIO_ODR Register Bit Definition + */ + +#define GPIO_ODR_ODRY_SHIFT (0) +#define GPIO_ODR_ODRY_MASK (0xFFFFU << GPIO_ODR_ODRY_SHIFT) +#define GPIO_ODR_ODRY(x) (((uint32_t)(((uint32_t)(x)) << GPIO_ODR_ODRY_SHIFT)) & GPIO_ODR_ODRY_MASK) + +/*! + * @brief GPIO_BSRR Register Bit Definition + */ + +#define GPIO_BSRR_BRY_SHIFT (16) +#define GPIO_BSRR_BRY_MASK (0xFFFFU << GPIO_BSRR_BRY_SHIFT) +#define GPIO_BSRR_BRY(x) (((uint32_t)(((uint32_t)(x)) << GPIO_BSRR_BRY_SHIFT)) & GPIO_BSRR_BRY_MASK) + +#define GPIO_BSRR_BSY_SHIFT (0) +#define GPIO_BSRR_BSY_MASK (0xFFFFU << GPIO_BSRR_BSY_SHIFT) +#define GPIO_BSRR_BSY(x) (((uint32_t)(((uint32_t)(x)) << GPIO_BSRR_BSY_SHIFT)) & GPIO_BSRR_BSY_MASK) + +/*! + * @brief GPIO_BRR Register Bit Definition + */ + +#define GPIO_BRR_BRY_SHIFT (0) +#define GPIO_BRR_BRY_MASK (0xFFFFU << GPIO_BRR_BRY_SHIFT) +#define GPIO_BRR_BRY(x) (((uint32_t)(((uint32_t)(x)) << GPIO_BRR_BRY_SHIFT)) & GPIO_BRR_BRY_MASK) + +/*! + * @brief GPIO_LCKR Register Bit Definition + */ + +#define GPIO_LCKR_LCKK_SHIFT (16) +#define GPIO_LCKR_LCKK_MASK (0x01U << GPIO_LCKR_LCKK_SHIFT) +#define GPIO_LCKR_LCKK(x) (((uint32_t)(((uint32_t)(x)) << GPIO_LCKR_LCKK_SHIFT)) & GPIO_LCKR_LCKK_MASK) + +#define GPIO_LCKR_LCK_SHIFT (0) +#define GPIO_LCKR_LCK_MASK (0xFFFFU << GPIO_LCKR_LCK_SHIFT) +#define GPIO_LCKR_LCK(x) (((uint32_t)(((uint32_t)(x)) << GPIO_LCKR_LCK_SHIFT)) & GPIO_LCKR_LCK_MASK) + +/*! + * @brief GPIO_DCR Register Bit Definition + */ + +#define GPIO_DCR_PX15PX1_SHIFT (2) +#define GPIO_DCR_PX15PX1_MASK (0x3FFFFFFFU << GPIO_DCR_PX15PX1_SHIFT) +#define GPIO_DCR_PX15PX1(x) (((uint32_t)(((uint32_t)(x)) << GPIO_DCR_PX15PX1_SHIFT)) & GPIO_DCR_PX15PX1_MASK) + +#define GPIO_DCR_PX0_SHIFT (0) +#define GPIO_DCR_PX0_MASK (0x3U << GPIO_DCR_PX0_SHIFT) +#define GPIO_DCR_PX0(x) (((uint32_t)(((uint32_t)(x)) << GPIO_DCR_PX0_SHIFT)) & GPIO_DCR_PX0_MASK) + +/*! + * @brief GPIO_AFRL Register Bit Definition + */ + +#define GPIO_AFRL_AFRY_SHIFT (0) +#define GPIO_AFRL_AFRY_MASK (0xFFFFFFFFU << GPIO_AFRL_AFRY_SHIFT) +#define GPIO_AFRL_AFRY(x) (((uint32_t)(((uint32_t)(x)) << GPIO_AFRL_AFRY_SHIFT)) & GPIO_AFRL_AFRY_MASK) + +/*! + * @brief GPIO_AFRH Register Bit Definition + */ + +#define GPIO_AFRH_AFRY_SHIFT (0) +#define GPIO_AFRH_AFRY_MASK (0xFFFFFFFFU << GPIO_AFRH_AFRY_SHIFT) +#define GPIO_AFRH_AFRY(x) (((uint32_t)(((uint32_t)(x)) << GPIO_AFRH_AFRY_SHIFT)) & GPIO_AFRH_AFRY_MASK) + +/*! + * @} + */ /* end of group GPIO_Register_Masks */ +/****************************************************************************** + * GPIO Instance +******************************************************************************/ +#define GPIOA ((GPIO_Type*)GPIOA_BASE) +#define GPIOB ((GPIO_Type*)GPIOB_BASE) +#define GPIOC ((GPIO_Type*)GPIOC_BASE) +#define GPIOD ((GPIO_Type*)GPIOD_BASE) +#define GPIOE ((GPIO_Type*)GPIOE_BASE) +#define GPIOF ((GPIO_Type*)GPIOF_BASE) +#define GPIOG ((GPIO_Type*)GPIOG_BASE) +#define GPIOH ((GPIO_Type*)GPIOH_BASE) + +/*! + * @} + */ /* end of group GPIO_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup TIM1_Peripheral_Access_Layer TIM1 Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * TIM1 Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR1; ///< Control register 1 offset: 0x00 + __IO uint32_t CR2; ///< Control register 2 offset: 0x04 + __IO uint32_t SMCR; ///< Slave mode control register offset: 0x08 + __IO uint32_t DIER; ///< DMA/interrupt enable register offset: 0x0C + __IO uint32_t SR; ///< Status register offset: 0x10 + __IO uint32_t EGR; ///< Event generation register offset: 0x14 + __IO uint32_t CCMR1; ///< Capture/compare mode register 1 offset: 0x18 + __IO uint32_t CCMR2; ///< Capture/compare mode register 2 offset: 0x1C + __IO uint32_t CCER; ///< Capture/compare enable register offset: 0x20 + __IO uint32_t CNT; ///< Counter offset: 0x24 + __IO uint32_t PSC; ///< Prescaler offset: 0x28 + __IO uint32_t ARR; ///< Autoload register offset: 0x2C + __IO uint32_t RCR; ///< Repeat count register offset: 0x30 + __IO uint32_t CCR[4]; +// __IO uint32_t CCR1; ///< Capture/compare register 1 offset: 0x34 +// __IO uint32_t CCR2; ///< Capture/compare register 2 offset: 0x38 +// __IO uint32_t CCR3; ///< Capture/compare register 3 offset: 0x3C +// __IO uint32_t CCR4; ///< Capture/compare register 4 offset: 0x40 + __IO uint32_t BDTR; ///< Brake and dead zone registers offset: 0x44 + __IO uint32_t DCR; ///< DMA control register offset: 0x48 + __IO uint32_t DMAR; ///< DMA address in continuous mode offset: 0x4C + __IO uint32_t Reserved7[1]; ///< Reserved + __IO uint32_t CCMR3; ///< Capture/compare mode register 3 offset: 0x54 + __IO uint32_t CCR5; ///< Capture/compare register 5 offset: 0x58 + __IO uint32_t PDER; ///< PWM phase shift/DMA repeat update request enable register offset: 0x5C + __IO uint32_t CCRFALL[5]; ///< PWM phase shift down counting capture/compare register offset: 0x60 +} TIM1_Type; + +/******************************************************************************* + * TIM1 Type + ******************************************************************************/ + +/*! + * @addtogroup TIM1_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM1_CR1 Register Bit Definition + */ + +#define TIM1_CR1_CKD_SHIFT (8) +#define TIM1_CR1_CKD_MASK (0x3U << TIM1_CR1_CKD_SHIFT) +#define TIM1_CR1_CKD(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_CKD_SHIFT)) & TIM1_CR1_CKD_MASK) + +#define TIM1_CR1_APRE_SHIFT (7) +#define TIM1_CR1_APRE_MASK (0x01U << TIM1_CR1_APRE_SHIFT) +#define TIM1_CR1_APRE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_APRE_SHIFT)) & TIM1_CR1_APRE_MASK) + +#define TIM1_CR1_CMS_SHIFT (5) +#define TIM1_CR1_CMS_MASK (0x3U << TIM1_CR1_CMS_SHIFT) +#define TIM1_CR1_CMS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_CMS_SHIFT)) & TIM1_CR1_CMS_MASK) + +#define TIM1_CR1_DIR_SHIFT (4) +#define TIM1_CR1_DIR_MASK (0x01U << TIM1_CR1_DIR_SHIFT) +#define TIM1_CR1_DIR(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_DIR_SHIFT)) & TIM1_CR1_DIR_MASK) + +#define TIM1_CR1_OPM_SHIFT (3) +#define TIM1_CR1_OPM_MASK (0x01U << TIM1_CR1_OPM_SHIFT) +#define TIM1_CR1_OPM(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_OPM_SHIFT)) & TIM1_CR1_OPM_MASK) + +#define TIM1_CR1_URS_SHIFT (2) +#define TIM1_CR1_URS_MASK (0x01U << TIM1_CR1_URS_SHIFT) +#define TIM1_CR1_URS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_URS_SHIFT)) & TIM1_CR1_URS_MASK) + +#define TIM1_CR1_UDIS_SHIFT (1) +#define TIM1_CR1_UDIS_MASK (0x01U << TIM1_CR1_UDIS_SHIFT) +#define TIM1_CR1_UDIS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_UDIS_SHIFT)) & TIM1_CR1_UDIS_MASK) + +#define TIM1_CR1_CEN_SHIFT (0) +#define TIM1_CR1_CEN_MASK (0x01U << TIM1_CR1_CEN_SHIFT) +#define TIM1_CR1_CEN(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR1_CEN_SHIFT)) & TIM1_CR1_CEN_MASK) + +/*! + * @brief TIM1_CR2 Register Bit Definition + */ + +#define TIM1_CR2_OIS4_SHIFT (14) +#define TIM1_CR2_OIS4_MASK (0x01U << TIM1_CR2_OIS4_SHIFT) +#define TIM1_CR2_OIS4(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_OIS4_SHIFT)) & TIM1_CR2_OIS4_MASK) + +#define TIM1_CR2_OIS3N_SHIFT (13) +#define TIM1_CR2_OIS3N_MASK (0x01U << TIM1_CR2_OIS3N_SHIFT) +#define TIM1_CR2_OIS3N(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_OIS3N_SHIFT)) & TIM1_CR2_OIS3N_MASK) + +#define TIM1_CR2_OIS3_SHIFT (12) +#define TIM1_CR2_OIS3_MASK (0x01U << TIM1_CR2_OIS3_SHIFT) +#define TIM1_CR2_OIS3(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_OIS3_SHIFT)) & TIM1_CR2_OIS3_MASK) + +#define TIM1_CR2_OIS2N_SHIFT (11) +#define TIM1_CR2_OIS2N_MASK (0x01U << TIM1_CR2_OIS2N_SHIFT) +#define TIM1_CR2_OIS2N(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_OIS2N_SHIFT)) & TIM1_CR2_OIS2N_MASK) + +#define TIM1_CR2_OIS2_SHIFT (10) +#define TIM1_CR2_OIS2_MASK (0x01U << TIM1_CR2_OIS2_SHIFT) +#define TIM1_CR2_OIS2(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_OIS2_SHIFT)) & TIM1_CR2_OIS2_MASK) + +#define TIM1_CR2_OIS1N_SHIFT (9) +#define TIM1_CR2_OIS1N_MASK (0x01U << TIM1_CR2_OIS1N_SHIFT) +#define TIM1_CR2_OIS1N(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_OIS1N_SHIFT)) & TIM1_CR2_OIS1N_MASK) + +#define TIM1_CR2_OIS1_SHIFT (8) +#define TIM1_CR2_OIS1_MASK (0x01U << TIM1_CR2_OIS1_SHIFT) +#define TIM1_CR2_OIS1(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_OIS1_SHIFT)) & TIM1_CR2_OIS1_MASK) + +#define TIM1_CR2_TI1S_SHIFT (7) +#define TIM1_CR2_TI1S_MASK (0x01U << TIM1_CR2_TI1S_SHIFT) +#define TIM1_CR2_TI1S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_TI1S_SHIFT)) & TIM1_CR2_TI1S_MASK) + +#define TIM1_CR2_MMS_SHIFT (4) +#define TIM1_CR2_MMS_MASK (0x7U << TIM1_CR2_MMS_SHIFT) +#define TIM1_CR2_MMS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_MMS_SHIFT)) & TIM1_CR2_MMS_MASK) + +#define TIM1_CR2_CCDS_SHIFT (3) +#define TIM1_CR2_CCDS_MASK (0x01U << TIM1_CR2_CCDS_SHIFT) +#define TIM1_CR2_CCDS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_CCDS_SHIFT)) & TIM1_CR2_CCDS_MASK) + +#define TIM1_CR2_CCUS_SHIFT (2) +#define TIM1_CR2_CCUS_MASK (0x01U << TIM1_CR2_CCUS_SHIFT) +#define TIM1_CR2_CCUS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_CCUS_SHIFT)) & TIM1_CR2_CCUS_MASK) + +#define TIM1_CR2_CCPC_SHIFT (0) +#define TIM1_CR2_CCPC_MASK (0x01U << TIM1_CR2_CCPC_SHIFT) +#define TIM1_CR2_CCPC(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CR2_CCPC_SHIFT)) & TIM1_CR2_CCPC_MASK) + +/*! + * @brief TIM1_SMCR Register Bit Definition + */ + +#define TIM1_SMCR_ETP_SHIFT (15) +#define TIM1_SMCR_ETP_MASK (0x01U << TIM1_SMCR_ETP_SHIFT) +#define TIM1_SMCR_ETP(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_ETP_SHIFT)) & TIM1_SMCR_ETP_MASK) + +#define TIM1_SMCR_ECE_SHIFT (14) +#define TIM1_SMCR_ECE_MASK (0x01U << TIM1_SMCR_ECE_SHIFT) +#define TIM1_SMCR_ECE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_ECE_SHIFT)) & TIM1_SMCR_ECE_MASK) + +#define TIM1_SMCR_ETPS_SHIFT (12) +#define TIM1_SMCR_ETPS_MASK (0x3U << TIM1_SMCR_ETPS_SHIFT) +#define TIM1_SMCR_ETPS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_ETPS_SHIFT)) & TIM1_SMCR_ETPS_MASK) + +#define TIM1_SMCR_ETF_SHIFT (8) +#define TIM1_SMCR_ETF_MASK (0xFU << TIM1_SMCR_ETF_SHIFT) +#define TIM1_SMCR_ETF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_ETF_SHIFT)) & TIM1_SMCR_ETF_MASK) + +#define TIM1_SMCR_MSM_SHIFT (7) +#define TIM1_SMCR_MSM_MASK (0x01U << TIM1_SMCR_MSM_SHIFT) +#define TIM1_SMCR_MSM(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_MSM_SHIFT)) & TIM1_SMCR_MSM_MASK) + +#define TIM1_SMCR_TS_SHIFT (4) +#define TIM1_SMCR_TS_MASK (0x7U << TIM1_SMCR_TS_SHIFT) +#define TIM1_SMCR_TS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_TS_SHIFT)) & TIM1_SMCR_TS_MASK) + +#define TIM1_SMCR_OCCS_SHIFT (3) +#define TIM1_SMCR_OCCS_MASK (0x01U << TIM1_SMCR_OCCS_SHIFT) +#define TIM1_SMCR_OCCS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_OCCS_SHIFT)) & TIM1_SMCR_OCCS_MASK) + +#define TIM1_SMCR_SMS_SHIFT (0) +#define TIM1_SMCR_SMS_MASK (0x7U << TIM1_SMCR_SMS_SHIFT) +#define TIM1_SMCR_SMS(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SMCR_SMS_SHIFT)) & TIM1_SMCR_SMS_MASK) + +/*! + * @brief TIM1_DIER Register Bit Definition + */ + +#define TIM1_DIER_CC5DE_SHIFT (17) +#define TIM1_DIER_CC5DE_MASK (0x01U << TIM1_DIER_CC5DE_SHIFT) +#define TIM1_DIER_CC5DE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC5DE_SHIFT)) & TIM1_DIER_CC5DE_MASK) + +#define TIM1_DIER_CC5IE_SHIFT (16) +#define TIM1_DIER_CC5IE_MASK (0x01U << TIM1_DIER_CC5IE_SHIFT) +#define TIM1_DIER_CC5IE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC5IE_SHIFT)) & TIM1_DIER_CC5IE_MASK) + +#define TIM1_DIER_TDE_SHIFT (14) +#define TIM1_DIER_TDE_MASK (0x01U << TIM1_DIER_TDE_SHIFT) +#define TIM1_DIER_TDE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_TDE_SHIFT)) & TIM1_DIER_TDE_MASK) + +#define TIM1_DIER_COMDE_SHIFT (13) +#define TIM1_DIER_COMDE_MASK (0x01U << TIM1_DIER_COMDE_SHIFT) +#define TIM1_DIER_COMDE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_COMDE_SHIFT)) & TIM1_DIER_COMDE_MASK) + +#define TIM1_DIER_CC4DE_SHIFT (12) +#define TIM1_DIER_CC4DE_MASK (0x01U << TIM1_DIER_CC4DE_SHIFT) +#define TIM1_DIER_CC4DE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC4DE_SHIFT)) & TIM1_DIER_CC4DE_MASK) + +#define TIM1_DIER_CC3DE_SHIFT (11) +#define TIM1_DIER_CC3DE_MASK (0x01U << TIM1_DIER_CC3DE_SHIFT) +#define TIM1_DIER_CC3DE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC3DE_SHIFT)) & TIM1_DIER_CC3DE_MASK) + +#define TIM1_DIER_CC2DE_SHIFT (10) +#define TIM1_DIER_CC2DE_MASK (0x01U << TIM1_DIER_CC2DE_SHIFT) +#define TIM1_DIER_CC2DE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC2DE_SHIFT)) & TIM1_DIER_CC2DE_MASK) + +#define TIM1_DIER_CC1DE_SHIFT (9) +#define TIM1_DIER_CC1DE_MASK (0x01U << TIM1_DIER_CC1DE_SHIFT) +#define TIM1_DIER_CC1DE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC1DE_SHIFT)) & TIM1_DIER_CC1DE_MASK) + +#define TIM1_DIER_UDE_SHIFT (8) +#define TIM1_DIER_UDE_MASK (0x01U << TIM1_DIER_UDE_SHIFT) +#define TIM1_DIER_UDE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_UDE_SHIFT)) & TIM1_DIER_UDE_MASK) + +#define TIM1_DIER_BIE_SHIFT (7) +#define TIM1_DIER_BIE_MASK (0x01U << TIM1_DIER_BIE_SHIFT) +#define TIM1_DIER_BIE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_BIE_SHIFT)) & TIM1_DIER_BIE_MASK) + +#define TIM1_DIER_TIE_SHIFT (6) +#define TIM1_DIER_TIE_MASK (0x01U << TIM1_DIER_TIE_SHIFT) +#define TIM1_DIER_TIE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_TIE_SHIFT)) & TIM1_DIER_TIE_MASK) + +#define TIM1_DIER_COMIE_SHIFT (5) +#define TIM1_DIER_COMIE_MASK (0x01U << TIM1_DIER_COMIE_SHIFT) +#define TIM1_DIER_COMIE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_COMIE_SHIFT)) & TIM1_DIER_COMIE_MASK) + +#define TIM1_DIER_CC4IE_SHIFT (4) +#define TIM1_DIER_CC4IE_MASK (0x01U << TIM1_DIER_CC4IE_SHIFT) +#define TIM1_DIER_CC4IE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC4IE_SHIFT)) & TIM1_DIER_CC4IE_MASK) + +#define TIM1_DIER_CC3IE_SHIFT (3) +#define TIM1_DIER_CC3IE_MASK (0x01U << TIM1_DIER_CC3IE_SHIFT) +#define TIM1_DIER_CC3IE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC3IE_SHIFT)) & TIM1_DIER_CC3IE_MASK) + +#define TIM1_DIER_CC2IE_SHIFT (2) +#define TIM1_DIER_CC2IE_MASK (0x01U << TIM1_DIER_CC2IE_SHIFT) +#define TIM1_DIER_CC2IE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC2IE_SHIFT)) & TIM1_DIER_CC2IE_MASK) + +#define TIM1_DIER_CC1IE_SHIFT (1) +#define TIM1_DIER_CC1IE_MASK (0x01U << TIM1_DIER_CC1IE_SHIFT) +#define TIM1_DIER_CC1IE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_CC1IE_SHIFT)) & TIM1_DIER_CC1IE_MASK) + +#define TIM1_DIER_UIE_SHIFT (0) +#define TIM1_DIER_UIE_MASK (0x01U << TIM1_DIER_UIE_SHIFT) +#define TIM1_DIER_UIE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DIER_UIE_SHIFT)) & TIM1_DIER_UIE_MASK) + +/*! + * @brief TIM1_SR Register Bit Definition + */ + +#define TIM1_SR_CC5IF_SHIFT (16) +#define TIM1_SR_CC5IF_MASK (0x01U << TIM1_SR_CC5IF_SHIFT) +#define TIM1_SR_CC5IF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC5IF_SHIFT)) & TIM1_SR_CC5IF_MASK) + +#define TIM1_SR_CC4OF_SHIFT (12) +#define TIM1_SR_CC4OF_MASK (0x01U << TIM1_SR_CC4OF_SHIFT) +#define TIM1_SR_CC4OF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC4OF_SHIFT)) & TIM1_SR_CC4OF_MASK) + +#define TIM1_SR_CC3OF_SHIFT (11) +#define TIM1_SR_CC3OF_MASK (0x01U << TIM1_SR_CC3OF_SHIFT) +#define TIM1_SR_CC3OF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC3OF_SHIFT)) & TIM1_SR_CC3OF_MASK) + +#define TIM1_SR_CC2OF_SHIFT (10) +#define TIM1_SR_CC2OF_MASK (0x01U << TIM1_SR_CC2OF_SHIFT) +#define TIM1_SR_CC2OF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC2OF_SHIFT)) & TIM1_SR_CC2OF_MASK) + +#define TIM1_SR_CC1OF_SHIFT (9) +#define TIM1_SR_CC1OF_MASK (0x01U << TIM1_SR_CC1OF_SHIFT) +#define TIM1_SR_CC1OF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC1OF_SHIFT)) & TIM1_SR_CC1OF_MASK) + +#define TIM1_SR_BIF_SHIFT (7) +#define TIM1_SR_BIF_MASK (0x01U << TIM1_SR_BIF_SHIFT) +#define TIM1_SR_BIF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_BIF_SHIFT)) & TIM1_SR_BIF_MASK) + +#define TIM1_SR_TIF_SHIFT (6) +#define TIM1_SR_TIF_MASK (0x01U << TIM1_SR_TIF_SHIFT) +#define TIM1_SR_TIF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_TIF_SHIFT)) & TIM1_SR_TIF_MASK) + +#define TIM1_SR_COMIF_SHIFT (5) +#define TIM1_SR_COMIF_MASK (0x01U << TIM1_SR_COMIF_SHIFT) +#define TIM1_SR_COMIF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_COMIF_SHIFT)) & TIM1_SR_COMIF_MASK) + +#define TIM1_SR_CC4IF_SHIFT (4) +#define TIM1_SR_CC4IF_MASK (0x01U << TIM1_SR_CC4IF_SHIFT) +#define TIM1_SR_CC4IF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC4IF_SHIFT)) & TIM1_SR_CC4IF_MASK) + +#define TIM1_SR_CC3IF_SHIFT (3) +#define TIM1_SR_CC3IF_MASK (0x01U << TIM1_SR_CC3IF_SHIFT) +#define TIM1_SR_CC3IF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC3IF_SHIFT)) & TIM1_SR_CC3IF_MASK) + +#define TIM1_SR_CC2IF_SHIFT (2) +#define TIM1_SR_CC2IF_MASK (0x01U << TIM1_SR_CC2IF_SHIFT) +#define TIM1_SR_CC2IF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC2IF_SHIFT)) & TIM1_SR_CC2IF_MASK) + +#define TIM1_SR_CC1IF_SHIFT (1) +#define TIM1_SR_CC1IF_MASK (0x01U << TIM1_SR_CC1IF_SHIFT) +#define TIM1_SR_CC1IF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_CC1IF_SHIFT)) & TIM1_SR_CC1IF_MASK) + +#define TIM1_SR_UIF_SHIFT (0) +#define TIM1_SR_UIF_MASK (0x01U << TIM1_SR_UIF_SHIFT) +#define TIM1_SR_UIF(x) (((uint32_t)(((uint32_t)(x)) << TIM1_SR_UIF_SHIFT)) & TIM1_SR_UIF_MASK) + +/*! + * @brief TIM1_EGR Register Bit Definition + */ + +#define TIM1_EGR_CC5G_SHIFT (16) +#define TIM1_EGR_CC5G_MASK (0x01U << TIM1_EGR_CC5G_SHIFT) +#define TIM1_EGR_CC5G(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_CC5G_SHIFT)) & TIM1_EGR_CC5G_MASK) + +#define TIM1_EGR_BG_SHIFT (7) +#define TIM1_EGR_BG_MASK (0x01U << TIM1_EGR_BG_SHIFT) +#define TIM1_EGR_BG(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_BG_SHIFT)) & TIM1_EGR_BG_MASK) + +#define TIM1_EGR_TG_SHIFT (6) +#define TIM1_EGR_TG_MASK (0x01U << TIM1_EGR_TG_SHIFT) +#define TIM1_EGR_TG(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_TG_SHIFT)) & TIM1_EGR_TG_MASK) + +#define TIM1_EGR_COMG_SHIFT (5) +#define TIM1_EGR_COMG_MASK (0x01U << TIM1_EGR_COMG_SHIFT) +#define TIM1_EGR_COMG(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_COMG_SHIFT)) & TIM1_EGR_COMG_MASK) + +#define TIM1_EGR_CC4G_SHIFT (4) +#define TIM1_EGR_CC4G_MASK (0x01U << TIM1_EGR_CC4G_SHIFT) +#define TIM1_EGR_CC4G(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_CC4G_SHIFT)) & TIM1_EGR_CC4G_MASK) + +#define TIM1_EGR_CC3G_SHIFT (3) +#define TIM1_EGR_CC3G_MASK (0x01U << TIM1_EGR_CC3G_SHIFT) +#define TIM1_EGR_CC3G(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_CC3G_SHIFT)) & TIM1_EGR_CC3G_MASK) + +#define TIM1_EGR_CC2G_SHIFT (2) +#define TIM1_EGR_CC2G_MASK (0x01U << TIM1_EGR_CC2G_SHIFT) +#define TIM1_EGR_CC2G(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_CC2G_SHIFT)) & TIM1_EGR_CC2G_MASK) + +#define TIM1_EGR_CC1G_SHIFT (1) +#define TIM1_EGR_CC1G_MASK (0x01U << TIM1_EGR_CC1G_SHIFT) +#define TIM1_EGR_CC1G(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_CC1G_SHIFT)) & TIM1_EGR_CC1G_MASK) + +#define TIM1_EGR_UG_SHIFT (0) +#define TIM1_EGR_UG_MASK (0x01U << TIM1_EGR_UG_SHIFT) +#define TIM1_EGR_UG(x) (((uint32_t)(((uint32_t)(x)) << TIM1_EGR_UG_SHIFT)) & TIM1_EGR_UG_MASK) + +/*! + * @brief TIM1_CCMR1 Register Bit Definition + */ + +#define TIM1_CCMR1_OC2CE_SHIFT (15) +#define TIM1_CCMR1_OC2CE_MASK (0x01U << TIM1_CCMR1_OC2CE_SHIFT) +#define TIM1_CCMR1_OC2CE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC2CE_SHIFT)) & TIM1_CCMR1_OC2CE_MASK) + +#define TIM1_CCMR1_OC2M_SHIFT (12) +#define TIM1_CCMR1_OC2M_MASK (0x7U << TIM1_CCMR1_OC2M_SHIFT) +#define TIM1_CCMR1_OC2M(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC2M_SHIFT)) & TIM1_CCMR1_OC2M_MASK) + +#define TIM1_CCMR1_OC2PE_SHIFT (11) +#define TIM1_CCMR1_OC2PE_MASK (0x01U << TIM1_CCMR1_OC2PE_SHIFT) +#define TIM1_CCMR1_OC2PE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC2PE_SHIFT)) & TIM1_CCMR1_OC2PE_MASK) + +#define TIM1_CCMR1_OC2FE_SHIFT (10) +#define TIM1_CCMR1_OC2FE_MASK (0x01U << TIM1_CCMR1_OC2FE_SHIFT) +#define TIM1_CCMR1_OC2FE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC2FE_SHIFT)) & TIM1_CCMR1_OC2FE_MASK) + +#define TIM1_CCMR1_CC2S_SHIFT (8) +#define TIM1_CCMR1_CC2S_MASK (0x3U << TIM1_CCMR1_CC2S_SHIFT) +#define TIM1_CCMR1_CC2S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_CC2S_SHIFT)) & TIM1_CCMR1_CC2S_MASK) + +#define TIM1_CCMR1_OC1CE_SHIFT (7) +#define TIM1_CCMR1_OC1CE_MASK (0x01U << TIM1_CCMR1_OC1CE_SHIFT) +#define TIM1_CCMR1_OC1CE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC1CE_SHIFT)) & TIM1_CCMR1_OC1CE_MASK) + +#define TIM1_CCMR1_OC1M_SHIFT (4) +#define TIM1_CCMR1_OC1M_MASK (0x7U << TIM1_CCMR1_OC1M_SHIFT) +#define TIM1_CCMR1_OC1M(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC1M_SHIFT)) & TIM1_CCMR1_OC1M_MASK) + +#define TIM1_CCMR1_OC1PE_SHIFT (3) +#define TIM1_CCMR1_OC1PE_MASK (0x01U << TIM1_CCMR1_OC1PE_SHIFT) +#define TIM1_CCMR1_OC1PE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC1PE_SHIFT)) & TIM1_CCMR1_OC1PE_MASK) + +#define TIM1_CCMR1_OC1FE_SHIFT (2) +#define TIM1_CCMR1_OC1FE_MASK (0x01U << TIM1_CCMR1_OC1FE_SHIFT) +#define TIM1_CCMR1_OC1FE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_OC1FE_SHIFT)) & TIM1_CCMR1_OC1FE_MASK) + +#define TIM1_CCMR1_CC1S_SHIFT (0) +#define TIM1_CCMR1_CC1S_MASK (0x3U << TIM1_CCMR1_CC1S_SHIFT) +#define TIM1_CCMR1_CC1S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_CC1S_SHIFT)) & TIM1_CCMR1_CC1S_MASK) + +/*! + * @brief TIM1_CCMR1 Register Bit Definition + */ + +#define TIM1_CCMR1_IC2F_SHIFT (12) +#define TIM1_CCMR1_IC2F_MASK (0xFU << TIM1_CCMR1_IC2F_SHIFT) +#define TIM1_CCMR1_IC2F(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_IC2F_SHIFT)) & TIM1_CCMR1_IC2F_MASK) + +#define TIM1_CCMR1_IC2PSC_SHIFT (10) +#define TIM1_CCMR1_IC2PSC_MASK (0x3U << TIM1_CCMR1_IC2PSC_SHIFT) +#define TIM1_CCMR1_IC2PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_IC2PSC_SHIFT)) & TIM1_CCMR1_IC2PSC_MASK) + +#define TIM1_CCMR1_CC2S_SHIFT (8) +#define TIM1_CCMR1_CC2S_MASK (0x3U << TIM1_CCMR1_CC2S_SHIFT) +#define TIM1_CCMR1_CC2S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_CC2S_SHIFT)) & TIM1_CCMR1_CC2S_MASK) + +#define TIM1_CCMR1_IC1F_SHIFT (4) +#define TIM1_CCMR1_IC1F_MASK (0xFU << TIM1_CCMR1_IC1F_SHIFT) +#define TIM1_CCMR1_IC1F(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_IC1F_SHIFT)) & TIM1_CCMR1_IC1F_MASK) + +#define TIM1_CCMR1_IC1PSC_SHIFT (2) +#define TIM1_CCMR1_IC1PSC_MASK (0x3U << TIM1_CCMR1_IC1PSC_SHIFT) +#define TIM1_CCMR1_IC1PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_IC1PSC_SHIFT)) & TIM1_CCMR1_IC1PSC_MASK) + +#define TIM1_CCMR1_CC1S_SHIFT (0) +#define TIM1_CCMR1_CC1S_MASK (0x3U << TIM1_CCMR1_CC1S_SHIFT) +#define TIM1_CCMR1_CC1S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR1_CC1S_SHIFT)) & TIM1_CCMR1_CC1S_MASK) + +/*! + * @brief TIM1_CCMR2 Register Bit Definition + */ + +#define TIM1_CCMR2_OC4CE_SHIFT (15) +#define TIM1_CCMR2_OC4CE_MASK (0x01U << TIM1_CCMR2_OC4CE_SHIFT) +#define TIM1_CCMR2_OC4CE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC4CE_SHIFT)) & TIM1_CCMR2_OC4CE_MASK) + +#define TIM1_CCMR2_OC4M_SHIFT (12) +#define TIM1_CCMR2_OC4M_MASK (0x7U << TIM1_CCMR2_OC4M_SHIFT) +#define TIM1_CCMR2_OC4M(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC4M_SHIFT)) & TIM1_CCMR2_OC4M_MASK) + +#define TIM1_CCMR2_OC4PE_SHIFT (11) +#define TIM1_CCMR2_OC4PE_MASK (0x01U << TIM1_CCMR2_OC4PE_SHIFT) +#define TIM1_CCMR2_OC4PE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC4PE_SHIFT)) & TIM1_CCMR2_OC4PE_MASK) + +#define TIM1_CCMR2_OC4FE_SHIFT (10) +#define TIM1_CCMR2_OC4FE_MASK (0x01U << TIM1_CCMR2_OC4FE_SHIFT) +#define TIM1_CCMR2_OC4FE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC4FE_SHIFT)) & TIM1_CCMR2_OC4FE_MASK) + +#define TIM1_CCMR2_CC4S_SHIFT (8) +#define TIM1_CCMR2_CC4S_MASK (0x3U << TIM1_CCMR2_CC4S_SHIFT) +#define TIM1_CCMR2_CC4S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_CC4S_SHIFT)) & TIM1_CCMR2_CC4S_MASK) + +#define TIM1_CCMR2_OC3CE_SHIFT (7) +#define TIM1_CCMR2_OC3CE_MASK (0x01U << TIM1_CCMR2_OC3CE_SHIFT) +#define TIM1_CCMR2_OC3CE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC3CE_SHIFT)) & TIM1_CCMR2_OC3CE_MASK) + +#define TIM1_CCMR2_OC3M_SHIFT (4) +#define TIM1_CCMR2_OC3M_MASK (0x7U << TIM1_CCMR2_OC3M_SHIFT) +#define TIM1_CCMR2_OC3M(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC3M_SHIFT)) & TIM1_CCMR2_OC3M_MASK) + +#define TIM1_CCMR2_OC3PE_SHIFT (3) +#define TIM1_CCMR2_OC3PE_MASK (0x01U << TIM1_CCMR2_OC3PE_SHIFT) +#define TIM1_CCMR2_OC3PE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC3PE_SHIFT)) & TIM1_CCMR2_OC3PE_MASK) + +#define TIM1_CCMR2_OC3FE_SHIFT (2) +#define TIM1_CCMR2_OC3FE_MASK (0x01U << TIM1_CCMR2_OC3FE_SHIFT) +#define TIM1_CCMR2_OC3FE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_OC3FE_SHIFT)) & TIM1_CCMR2_OC3FE_MASK) + +#define TIM1_CCMR2_CC3S_SHIFT (0) +#define TIM1_CCMR2_CC3S_MASK (0x3U << TIM1_CCMR2_CC3S_SHIFT) +#define TIM1_CCMR2_CC3S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_CC3S_SHIFT)) & TIM1_CCMR2_CC3S_MASK) + +/*! + * @brief TIM1_CCMR2 Register Bit Definition + */ + +#define TIM1_CCMR2_IC4F_SHIFT (12) +#define TIM1_CCMR2_IC4F_MASK (0xFU << TIM1_CCMR2_IC4F_SHIFT) +#define TIM1_CCMR2_IC4F(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_IC4F_SHIFT)) & TIM1_CCMR2_IC4F_MASK) + +#define TIM1_CCMR2_IC4PSC_SHIFT (10) +#define TIM1_CCMR2_IC4PSC_MASK (0x3U << TIM1_CCMR2_IC4PSC_SHIFT) +#define TIM1_CCMR2_IC4PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_IC4PSC_SHIFT)) & TIM1_CCMR2_IC4PSC_MASK) + +#define TIM1_CCMR2_CC4S_SHIFT (8) +#define TIM1_CCMR2_CC4S_MASK (0x3U << TIM1_CCMR2_CC4S_SHIFT) +#define TIM1_CCMR2_CC4S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_CC4S_SHIFT)) & TIM1_CCMR2_CC4S_MASK) + +#define TIM1_CCMR2_IC3F_SHIFT (4) +#define TIM1_CCMR2_IC3F_MASK (0xFU << TIM1_CCMR2_IC3F_SHIFT) +#define TIM1_CCMR2_IC3F(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_IC3F_SHIFT)) & TIM1_CCMR2_IC3F_MASK) + +#define TIM1_CCMR2_IC3PSC_SHIFT (2) +#define TIM1_CCMR2_IC3PSC_MASK (0x3U << TIM1_CCMR2_IC3PSC_SHIFT) +#define TIM1_CCMR2_IC3PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_IC3PSC_SHIFT)) & TIM1_CCMR2_IC3PSC_MASK) + +#define TIM1_CCMR2_CC3S_SHIFT (0) +#define TIM1_CCMR2_CC3S_MASK (0x3U << TIM1_CCMR2_CC3S_SHIFT) +#define TIM1_CCMR2_CC3S(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR2_CC3S_SHIFT)) & TIM1_CCMR2_CC3S_MASK) + +/*! + * @brief TIM1_CCER Register Bit Definition + */ + +#define TIM1_CCER_CC4NP_SHIFT (15) +#define TIM1_CCER_CC4NP_MASK (0x01U << TIM1_CCER_CC4NP_SHIFT) +#define TIM1_CCER_CC4NP(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC4NP_SHIFT)) & TIM1_CCER_CC4NP_MASK) + +#define TIM1_CCER_CC4P_SHIFT (13) +#define TIM1_CCER_CC4P_MASK (0x01U << TIM1_CCER_CC4P_SHIFT) +#define TIM1_CCER_CC4P(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC4P_SHIFT)) & TIM1_CCER_CC4P_MASK) + +#define TIM1_CCER_CC4E_SHIFT (12) +#define TIM1_CCER_CC4E_MASK (0x01U << TIM1_CCER_CC4E_SHIFT) +#define TIM1_CCER_CC4E(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC4E_SHIFT)) & TIM1_CCER_CC4E_MASK) + +#define TIM1_CCER_CC3NP_SHIFT (11) +#define TIM1_CCER_CC3NP_MASK (0x01U << TIM1_CCER_CC3NP_SHIFT) +#define TIM1_CCER_CC3NP(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC3NP_SHIFT)) & TIM1_CCER_CC3NP_MASK) + +#define TIM1_CCER_CC3NE_SHIFT (10) +#define TIM1_CCER_CC3NE_MASK (0x01U << TIM1_CCER_CC3NE_SHIFT) +#define TIM1_CCER_CC3NE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC3NE_SHIFT)) & TIM1_CCER_CC3NE_MASK) + +#define TIM1_CCER_CC3P_SHIFT (9) +#define TIM1_CCER_CC3P_MASK (0x01U << TIM1_CCER_CC3P_SHIFT) +#define TIM1_CCER_CC3P(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC3P_SHIFT)) & TIM1_CCER_CC3P_MASK) + +#define TIM1_CCER_CC3E_SHIFT (8) +#define TIM1_CCER_CC3E_MASK (0x01U << TIM1_CCER_CC3E_SHIFT) +#define TIM1_CCER_CC3E(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC3E_SHIFT)) & TIM1_CCER_CC3E_MASK) + +#define TIM1_CCER_CC2NP_SHIFT (7) +#define TIM1_CCER_CC2NP_MASK (0x01U << TIM1_CCER_CC2NP_SHIFT) +#define TIM1_CCER_CC2NP(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC2NP_SHIFT)) & TIM1_CCER_CC2NP_MASK) + +#define TIM1_CCER_CC2NE_SHIFT (6) +#define TIM1_CCER_CC2NE_MASK (0x01U << TIM1_CCER_CC2NE_SHIFT) +#define TIM1_CCER_CC2NE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC2NE_SHIFT)) & TIM1_CCER_CC2NE_MASK) + +#define TIM1_CCER_CC2P_SHIFT (5) +#define TIM1_CCER_CC2P_MASK (0x01U << TIM1_CCER_CC2P_SHIFT) +#define TIM1_CCER_CC2P(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC2P_SHIFT)) & TIM1_CCER_CC2P_MASK) + +#define TIM1_CCER_CC2E_SHIFT (4) +#define TIM1_CCER_CC2E_MASK (0x01U << TIM1_CCER_CC2E_SHIFT) +#define TIM1_CCER_CC2E(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC2E_SHIFT)) & TIM1_CCER_CC2E_MASK) + +#define TIM1_CCER_CC1NP_SHIFT (3) +#define TIM1_CCER_CC1NP_MASK (0x01U << TIM1_CCER_CC1NP_SHIFT) +#define TIM1_CCER_CC1NP(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC1NP_SHIFT)) & TIM1_CCER_CC1NP_MASK) + +#define TIM1_CCER_CC1NE_SHIFT (2) +#define TIM1_CCER_CC1NE_MASK (0x01U << TIM1_CCER_CC1NE_SHIFT) +#define TIM1_CCER_CC1NE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC1NE_SHIFT)) & TIM1_CCER_CC1NE_MASK) + +#define TIM1_CCER_CC1P_SHIFT (1) +#define TIM1_CCER_CC1P_MASK (0x01U << TIM1_CCER_CC1P_SHIFT) +#define TIM1_CCER_CC1P(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC1P_SHIFT)) & TIM1_CCER_CC1P_MASK) + +#define TIM1_CCER_CC1E_SHIFT (0) +#define TIM1_CCER_CC1E_MASK (0x01U << TIM1_CCER_CC1E_SHIFT) +#define TIM1_CCER_CC1E(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCER_CC1E_SHIFT)) & TIM1_CCER_CC1E_MASK) + +/*! + * @brief TIM1_CNT Register Bit Definition + */ + +#define TIM1_CNT_CNT_SHIFT (0) +#define TIM1_CNT_CNT_MASK (0xFFFFU << TIM1_CNT_CNT_SHIFT) +#define TIM1_CNT_CNT(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CNT_CNT_SHIFT)) & TIM1_CNT_CNT_MASK) + +/*! + * @brief TIM1_PSC Register Bit Definition + */ + +#define TIM1_PSC_PSC_SHIFT (0) +#define TIM1_PSC_PSC_MASK (0xFFFFU << TIM1_PSC_PSC_SHIFT) +#define TIM1_PSC_PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM1_PSC_PSC_SHIFT)) & TIM1_PSC_PSC_MASK) + +/*! + * @brief TIM1_ARR Register Bit Definition + */ + +#define TIM1_ARR_ARR_SHIFT (0) +#define TIM1_ARR_ARR_MASK (0xFFFFU << TIM1_ARR_ARR_SHIFT) +#define TIM1_ARR_ARR(x) (((uint32_t)(((uint32_t)(x)) << TIM1_ARR_ARR_SHIFT)) & TIM1_ARR_ARR_MASK) + +/*! + * @brief TIM1_RCR Register Bit Definition + */ + +#define TIM1_RCR_REPCNT_SHIFT (8) +#define TIM1_RCR_REPCNT_MASK (0xFFU << TIM1_RCR_REPCNT_SHIFT) +#define TIM1_RCR_REPCNT(x) (((uint32_t)(((uint32_t)(x)) << TIM1_RCR_REPCNT_SHIFT)) & TIM1_RCR_REPCNT_MASK) + +#define TIM1_RCR_REP_SHIFT (0) +#define TIM1_RCR_REP_MASK (0xFFU << TIM1_RCR_REP_SHIFT) +#define TIM1_RCR_REP(x) (((uint32_t)(((uint32_t)(x)) << TIM1_RCR_REP_SHIFT)) & TIM1_RCR_REP_MASK) + +/*! + * @brief TIM1_CCR1 Register Bit Definition + */ + +#define TIM1_CCR1_CCR1_SHIFT (0) +#define TIM1_CCR1_CCR1_MASK (0xFFFFU << TIM1_CCR1_CCR1_SHIFT) +#define TIM1_CCR1_CCR1(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCR1_CCR1_SHIFT)) & TIM1_CCR1_CCR1_MASK) + +/*! + * @brief TIM1_CCR2 Register Bit Definition + */ + +#define TIM1_CCR2_CCR2_SHIFT (0) +#define TIM1_CCR2_CCR2_MASK (0xFFFFU << TIM1_CCR2_CCR2_SHIFT) +#define TIM1_CCR2_CCR2(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCR2_CCR2_SHIFT)) & TIM1_CCR2_CCR2_MASK) + +/*! + * @brief TIM1_CCR3 Register Bit Definition + */ + +#define TIM1_CCR3_CCR3_SHIFT (0) +#define TIM1_CCR3_CCR3_MASK (0xFFFFU << TIM1_CCR3_CCR3_SHIFT) +#define TIM1_CCR3_CCR3(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCR3_CCR3_SHIFT)) & TIM1_CCR3_CCR3_MASK) + +/*! + * @brief TIM1_CCR4 Register Bit Definition + */ + +#define TIM1_CCR4_CCR4_SHIFT (0) +#define TIM1_CCR4_CCR4_MASK (0xFFFFU << TIM1_CCR4_CCR4_SHIFT) +#define TIM1_CCR4_CCR4(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCR4_CCR4_SHIFT)) & TIM1_CCR4_CCR4_MASK) + +/*! + * @brief TIM1_BDTR Register Bit Definition + */ + +#define TIM1_BDTR_DOE_SHIFT (16) +#define TIM1_BDTR_DOE_MASK (0x01U << TIM1_BDTR_DOE_SHIFT) +#define TIM1_BDTR_DOE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_DOE_SHIFT)) & TIM1_BDTR_DOE_MASK) + +#define TIM1_BDTR_MOE_SHIFT (15) +#define TIM1_BDTR_MOE_MASK (0x01U << TIM1_BDTR_MOE_SHIFT) +#define TIM1_BDTR_MOE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_MOE_SHIFT)) & TIM1_BDTR_MOE_MASK) + +#define TIM1_BDTR_AOE_SHIFT (14) +#define TIM1_BDTR_AOE_MASK (0x01U << TIM1_BDTR_AOE_SHIFT) +#define TIM1_BDTR_AOE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_AOE_SHIFT)) & TIM1_BDTR_AOE_MASK) + +#define TIM1_BDTR_BKP_SHIFT (13) +#define TIM1_BDTR_BKP_MASK (0x01U << TIM1_BDTR_BKP_SHIFT) +#define TIM1_BDTR_BKP(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_BKP_SHIFT)) & TIM1_BDTR_BKP_MASK) + +#define TIM1_BDTR_BKE_SHIFT (12) +#define TIM1_BDTR_BKE_MASK (0x01U << TIM1_BDTR_BKE_SHIFT) +#define TIM1_BDTR_BKE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_BKE_SHIFT)) & TIM1_BDTR_BKE_MASK) + +#define TIM1_BDTR_OSSR_SHIFT (11) +#define TIM1_BDTR_OSSR_MASK (0x01U << TIM1_BDTR_OSSR_SHIFT) +#define TIM1_BDTR_OSSR(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_OSSR_SHIFT)) & TIM1_BDTR_OSSR_MASK) + +#define TIM1_BDTR_OSSI_SHIFT (10) +#define TIM1_BDTR_OSSI_MASK (0x01U << TIM1_BDTR_OSSI_SHIFT) +#define TIM1_BDTR_OSSI(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_OSSI_SHIFT)) & TIM1_BDTR_OSSI_MASK) + +#define TIM1_BDTR_LOCK_SHIFT (8) +#define TIM1_BDTR_LOCK_MASK (0x3U << TIM1_BDTR_LOCK_SHIFT) +#define TIM1_BDTR_LOCK(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_LOCK_SHIFT)) & TIM1_BDTR_LOCK_MASK) + +#define TIM1_BDTR_DTG_SHIFT (0) +#define TIM1_BDTR_DTG_MASK (0xFFU << TIM1_BDTR_DTG_SHIFT) +#define TIM1_BDTR_DTG(x) (((uint32_t)(((uint32_t)(x)) << TIM1_BDTR_DTG_SHIFT)) & TIM1_BDTR_DTG_MASK) + +/*! + * @brief TIM1_DCR Register Bit Definition + */ + +#define TIM1_DCR_DBL_SHIFT (8) +#define TIM1_DCR_DBL_MASK (0x1FU << TIM1_DCR_DBL_SHIFT) +#define TIM1_DCR_DBL(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DCR_DBL_SHIFT)) & TIM1_DCR_DBL_MASK) + +#define TIM1_DCR_DBA_SHIFT (0) +#define TIM1_DCR_DBA_MASK (0x1FU << TIM1_DCR_DBA_SHIFT) +#define TIM1_DCR_DBA(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DCR_DBA_SHIFT)) & TIM1_DCR_DBA_MASK) + +/*! + * @brief TIM1_DMAR Register Bit Definition + */ + +#define TIM1_DMAR_DMAB_SHIFT (0) +#define TIM1_DMAR_DMAB_MASK (0xFFFFU << TIM1_DMAR_DMAB_SHIFT) +#define TIM1_DMAR_DMAB(x) (((uint32_t)(((uint32_t)(x)) << TIM1_DMAR_DMAB_SHIFT)) & TIM1_DMAR_DMAB_MASK) + +/*! + * @brief TIM1_CCMR3 Register Bit Definition + */ + +#define TIM1_CCMR3_OC5M_SHIFT (4) +#define TIM1_CCMR3_OC5M_MASK (0x7U << TIM1_CCMR3_OC5M_SHIFT) +#define TIM1_CCMR3_OC5M(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR3_OC5M_SHIFT)) & TIM1_CCMR3_OC5M_MASK) + +#define TIM1_CCMR3_OC5PE_SHIFT (3) +#define TIM1_CCMR3_OC5PE_MASK (0x01U << TIM1_CCMR3_OC5PE_SHIFT) +#define TIM1_CCMR3_OC5PE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR3_OC5PE_SHIFT)) & TIM1_CCMR3_OC5PE_MASK) + +#define TIM1_CCMR3_OC5FE_SHIFT (2) +#define TIM1_CCMR3_OC5FE_MASK (0x01U << TIM1_CCMR3_OC5FE_SHIFT) +#define TIM1_CCMR3_OC5FE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCMR3_OC5FE_SHIFT)) & TIM1_CCMR3_OC5FE_MASK) + +/*! + * @brief TIM1_CCR5 Register Bit Definition + */ + +#define TIM1_CCR5_CCR5_SHIFT (0) +#define TIM1_CCR5_CCR5_MASK (0xFFFFU << TIM1_CCR5_CCR5_SHIFT) +#define TIM1_CCR5_CCR5(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCR5_CCR5_SHIFT)) & TIM1_CCR5_CCR5_MASK) + +/*! + * @brief TIM1_PDER Register Bit Definition + */ + +#define TIM1_PDER_CCR5SHIFTEN_SHIFT (5) +#define TIM1_PDER_CCR5SHIFTEN_MASK (0x01U << TIM1_PDER_CCR5SHIFTEN_SHIFT) +#define TIM1_PDER_CCR5SHIFTEN(x) (((uint32_t)(((uint32_t)(x)) << TIM1_PDER_CCR5SHIFTEN_SHIFT)) & TIM1_PDER_CCR5SHIFTEN_MASK) + +#define TIM1_PDER_CCR4SHIFTEN_SHIFT (4) +#define TIM1_PDER_CCR4SHIFTEN_MASK (0x01U << TIM1_PDER_CCR4SHIFTEN_SHIFT) +#define TIM1_PDER_CCR4SHIFTEN(x) (((uint32_t)(((uint32_t)(x)) << TIM1_PDER_CCR4SHIFTEN_SHIFT)) & TIM1_PDER_CCR4SHIFTEN_MASK) + +#define TIM1_PDER_CCR3SHIFTEN_SHIFT (3) +#define TIM1_PDER_CCR3SHIFTEN_MASK (0x01U << TIM1_PDER_CCR3SHIFTEN_SHIFT) +#define TIM1_PDER_CCR3SHIFTEN(x) (((uint32_t)(((uint32_t)(x)) << TIM1_PDER_CCR3SHIFTEN_SHIFT)) & TIM1_PDER_CCR3SHIFTEN_MASK) + +#define TIM1_PDER_CCR2SHIFTEN_SHIFT (2) +#define TIM1_PDER_CCR2SHIFTEN_MASK (0x01U << TIM1_PDER_CCR2SHIFTEN_SHIFT) +#define TIM1_PDER_CCR2SHIFTEN(x) (((uint32_t)(((uint32_t)(x)) << TIM1_PDER_CCR2SHIFTEN_SHIFT)) & TIM1_PDER_CCR2SHIFTEN_MASK) + +#define TIM1_PDER_CCR1SHIFTEN_SHIFT (1) +#define TIM1_PDER_CCR1SHIFTEN_MASK (0x01U << TIM1_PDER_CCR1SHIFTEN_SHIFT) +#define TIM1_PDER_CCR1SHIFTEN(x) (((uint32_t)(((uint32_t)(x)) << TIM1_PDER_CCR1SHIFTEN_SHIFT)) & TIM1_PDER_CCR1SHIFTEN_MASK) + +#define TIM1_PDER_CCDREPE_SHIFT (0) +#define TIM1_PDER_CCDREPE_MASK (0x01U << TIM1_PDER_CCDREPE_SHIFT) +#define TIM1_PDER_CCDREPE(x) (((uint32_t)(((uint32_t)(x)) << TIM1_PDER_CCDREPE_SHIFT)) & TIM1_PDER_CCDREPE_MASK) + +/*! + * @brief TIM1_CCRFALL Register Bit Definition + */ + +#define TIM1_CCRFALL_CCRXFALL_SHIFT (0) +#define TIM1_CCRFALL_CCRXFALL_MASK (0xFFFFU << TIM1_CCRFALL_CCRXFALL_SHIFT) +#define TIM1_CCRFALL_CCRXFALL(x) (((uint32_t)(((uint32_t)(x)) << TIM1_CCRFALL_CCRXFALL_SHIFT)) & TIM1_CCRFALL_CCRXFALL_MASK) + +/*! + * @} + */ /* end of group TIM1_Register_Masks */ +/****************************************************************************** + * TIM1/8 Instance +******************************************************************************/ +#define TIM1 ((TIM1_Type*)TIM1_BASE) +#define TIM8 ((TIM1_Type*)TIM8_BASE) + +/*! + * @} + */ /* end of group TIM1_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup TIM3_Peripheral_Access_Layer TIM3 Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * TIM3 Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR1; ///< Control register 1 offset: 0x00 + __IO uint32_t CR2; ///< Control register 2 offset: 0x04 + __IO uint32_t SMCR; ///< Slave mode control register offset: 0x08 + __IO uint32_t DIER; ///< DMA/interrupt enable register offset: 0x0C + __IO uint32_t SR; ///< Status register offset: 0x10 + __IO uint32_t EGR; ///< Event generation register offset: 0x14 + __IO uint32_t CCMR1; ///< offset: 0x18 + __IO uint32_t CCMR2; ///< Capture/compare mode register 1 offset: 0x1C + __IO uint32_t CCER; ///< Capture/compare enable register offset: 0x20 + __IO uint32_t CNT; ///< Counter offset: 0x24 + __IO uint32_t PSC; ///< Prescaler offset: 0x28 + __IO uint32_t ARR; ///< Autoload register offset: 0x2C + __IO uint32_t Reserved8[1]; ///< Reserved + __IO uint32_t CCR[4]; +// __IO uint32_t CCR1; ///< Capture/compare register 1 offset: 0x34 +// __IO uint32_t CCR2; ///< Capture/compare register 2 offset: 0x38 +// __IO uint32_t CCR3; ///< Capture/compare register 3 offset: 0x3C +// __IO uint32_t CCR4; ///< Capture/compare register 4 offset: 0x40 + __IO uint32_t Reserved9[1]; ///< Reserved + __IO uint32_t DCR; ///< DMA control register offset: 0x48 + __IO uint32_t DMAR; ///< DMA address in continuous mode offset: 0x4C +} TIM3_Type; + +/******************************************************************************* + * TIM3 Type + ******************************************************************************/ + +/*! + * @addtogroup TIM3_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM3_CR1 Register Bit Definition + */ + +#define TIM3_CR1_CKD_SHIFT (8) +#define TIM3_CR1_CKD_MASK (0x3U << TIM3_CR1_CKD_SHIFT) +#define TIM3_CR1_CKD(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_CKD_SHIFT)) & TIM3_CR1_CKD_MASK) + +#define TIM3_CR1_APRE_SHIFT (7) +#define TIM3_CR1_APRE_MASK (0x01U << TIM3_CR1_APRE_SHIFT) +#define TIM3_CR1_APRE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_APRE_SHIFT)) & TIM3_CR1_APRE_MASK) + +#define TIM3_CR1_CMS_SHIFT (5) +#define TIM3_CR1_CMS_MASK (0x3U << TIM3_CR1_CMS_SHIFT) +#define TIM3_CR1_CMS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_CMS_SHIFT)) & TIM3_CR1_CMS_MASK) + +#define TIM3_CR1_DIR_SHIFT (4) +#define TIM3_CR1_DIR_MASK (0x01U << TIM3_CR1_DIR_SHIFT) +#define TIM3_CR1_DIR(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_DIR_SHIFT)) & TIM3_CR1_DIR_MASK) + +#define TIM3_CR1_OPM_SHIFT (3) +#define TIM3_CR1_OPM_MASK (0x01U << TIM3_CR1_OPM_SHIFT) +#define TIM3_CR1_OPM(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_OPM_SHIFT)) & TIM3_CR1_OPM_MASK) + +#define TIM3_CR1_URS_SHIFT (2) +#define TIM3_CR1_URS_MASK (0x01U << TIM3_CR1_URS_SHIFT) +#define TIM3_CR1_URS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_URS_SHIFT)) & TIM3_CR1_URS_MASK) + +#define TIM3_CR1_UDIS_SHIFT (1) +#define TIM3_CR1_UDIS_MASK (0x01U << TIM3_CR1_UDIS_SHIFT) +#define TIM3_CR1_UDIS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_UDIS_SHIFT)) & TIM3_CR1_UDIS_MASK) + +#define TIM3_CR1_CEN_SHIFT (0) +#define TIM3_CR1_CEN_MASK (0x01U << TIM3_CR1_CEN_SHIFT) +#define TIM3_CR1_CEN(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR1_CEN_SHIFT)) & TIM3_CR1_CEN_MASK) + +/*! + * @brief TIM3_CR2 Register Bit Definition + */ + +#define TIM3_CR2_TI1S_SHIFT (7) +#define TIM3_CR2_TI1S_MASK (0x01U << TIM3_CR2_TI1S_SHIFT) +#define TIM3_CR2_TI1S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR2_TI1S_SHIFT)) & TIM3_CR2_TI1S_MASK) + +#define TIM3_CR2_MMS_SHIFT (4) +#define TIM3_CR2_MMS_MASK (0x7U << TIM3_CR2_MMS_SHIFT) +#define TIM3_CR2_MMS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR2_MMS_SHIFT)) & TIM3_CR2_MMS_MASK) + +#define TIM3_CR2_CCDS_SHIFT (3) +#define TIM3_CR2_CCDS_MASK (0x01U << TIM3_CR2_CCDS_SHIFT) +#define TIM3_CR2_CCDS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CR2_CCDS_SHIFT)) & TIM3_CR2_CCDS_MASK) + +/*! + * @brief TIM3_SMCR Register Bit Definition + */ + +#define TIM3_SMCR_ETP_SHIFT (15) +#define TIM3_SMCR_ETP_MASK (0x01U << TIM3_SMCR_ETP_SHIFT) +#define TIM3_SMCR_ETP(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_ETP_SHIFT)) & TIM3_SMCR_ETP_MASK) + +#define TIM3_SMCR_ECE_SHIFT (14) +#define TIM3_SMCR_ECE_MASK (0x01U << TIM3_SMCR_ECE_SHIFT) +#define TIM3_SMCR_ECE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_ECE_SHIFT)) & TIM3_SMCR_ECE_MASK) + +#define TIM3_SMCR_ETPS_SHIFT (12) +#define TIM3_SMCR_ETPS_MASK (0x3U << TIM3_SMCR_ETPS_SHIFT) +#define TIM3_SMCR_ETPS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_ETPS_SHIFT)) & TIM3_SMCR_ETPS_MASK) + +#define TIM3_SMCR_ETF_SHIFT (8) +#define TIM3_SMCR_ETF_MASK (0xFU << TIM3_SMCR_ETF_SHIFT) +#define TIM3_SMCR_ETF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_ETF_SHIFT)) & TIM3_SMCR_ETF_MASK) + +#define TIM3_SMCR_MSM_SHIFT (7) +#define TIM3_SMCR_MSM_MASK (0x01U << TIM3_SMCR_MSM_SHIFT) +#define TIM3_SMCR_MSM(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_MSM_SHIFT)) & TIM3_SMCR_MSM_MASK) + +#define TIM3_SMCR_TS_SHIFT (4) +#define TIM3_SMCR_TS_MASK (0x7U << TIM3_SMCR_TS_SHIFT) +#define TIM3_SMCR_TS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_TS_SHIFT)) & TIM3_SMCR_TS_MASK) + +#define TIM3_SMCR_OCCS_SHIFT (3) +#define TIM3_SMCR_OCCS_MASK (0x01U << TIM3_SMCR_OCCS_SHIFT) +#define TIM3_SMCR_OCCS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_OCCS_SHIFT)) & TIM3_SMCR_OCCS_MASK) + +#define TIM3_SMCR_SMS_SHIFT (0) +#define TIM3_SMCR_SMS_MASK (0x7U << TIM3_SMCR_SMS_SHIFT) +#define TIM3_SMCR_SMS(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SMCR_SMS_SHIFT)) & TIM3_SMCR_SMS_MASK) + +/*! + * @brief TIM3_DIER Register Bit Definition + */ + +#define TIM3_DIER_TDE_SHIFT (14) +#define TIM3_DIER_TDE_MASK (0x01U << TIM3_DIER_TDE_SHIFT) +#define TIM3_DIER_TDE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_TDE_SHIFT)) & TIM3_DIER_TDE_MASK) + +#define TIM3_DIER_CC4DE_SHIFT (12) +#define TIM3_DIER_CC4DE_MASK (0x01U << TIM3_DIER_CC4DE_SHIFT) +#define TIM3_DIER_CC4DE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC4DE_SHIFT)) & TIM3_DIER_CC4DE_MASK) + +#define TIM3_DIER_CC3DE_SHIFT (11) +#define TIM3_DIER_CC3DE_MASK (0x01U << TIM3_DIER_CC3DE_SHIFT) +#define TIM3_DIER_CC3DE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC3DE_SHIFT)) & TIM3_DIER_CC3DE_MASK) + +#define TIM3_DIER_CC2DE_SHIFT (10) +#define TIM3_DIER_CC2DE_MASK (0x01U << TIM3_DIER_CC2DE_SHIFT) +#define TIM3_DIER_CC2DE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC2DE_SHIFT)) & TIM3_DIER_CC2DE_MASK) + +#define TIM3_DIER_CC1DE_SHIFT (9) +#define TIM3_DIER_CC1DE_MASK (0x01U << TIM3_DIER_CC1DE_SHIFT) +#define TIM3_DIER_CC1DE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC1DE_SHIFT)) & TIM3_DIER_CC1DE_MASK) + +#define TIM3_DIER_UDE_SHIFT (8) +#define TIM3_DIER_UDE_MASK (0x01U << TIM3_DIER_UDE_SHIFT) +#define TIM3_DIER_UDE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_UDE_SHIFT)) & TIM3_DIER_UDE_MASK) + +#define TIM3_DIER_TIE_SHIFT (6) +#define TIM3_DIER_TIE_MASK (0x01U << TIM3_DIER_TIE_SHIFT) +#define TIM3_DIER_TIE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_TIE_SHIFT)) & TIM3_DIER_TIE_MASK) + +#define TIM3_DIER_CC4IE_SHIFT (4) +#define TIM3_DIER_CC4IE_MASK (0x01U << TIM3_DIER_CC4IE_SHIFT) +#define TIM3_DIER_CC4IE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC4IE_SHIFT)) & TIM3_DIER_CC4IE_MASK) + +#define TIM3_DIER_CC3IE_SHIFT (3) +#define TIM3_DIER_CC3IE_MASK (0x01U << TIM3_DIER_CC3IE_SHIFT) +#define TIM3_DIER_CC3IE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC3IE_SHIFT)) & TIM3_DIER_CC3IE_MASK) + +#define TIM3_DIER_CC2IE_SHIFT (2) +#define TIM3_DIER_CC2IE_MASK (0x01U << TIM3_DIER_CC2IE_SHIFT) +#define TIM3_DIER_CC2IE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC2IE_SHIFT)) & TIM3_DIER_CC2IE_MASK) + +#define TIM3_DIER_CC1IE_SHIFT (1) +#define TIM3_DIER_CC1IE_MASK (0x01U << TIM3_DIER_CC1IE_SHIFT) +#define TIM3_DIER_CC1IE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_CC1IE_SHIFT)) & TIM3_DIER_CC1IE_MASK) + +#define TIM3_DIER_UIE_SHIFT (0) +#define TIM3_DIER_UIE_MASK (0x01U << TIM3_DIER_UIE_SHIFT) +#define TIM3_DIER_UIE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DIER_UIE_SHIFT)) & TIM3_DIER_UIE_MASK) + +/*! + * @brief TIM3_SR Register Bit Definition + */ + +#define TIM3_SR_CC4OF_SHIFT (12) +#define TIM3_SR_CC4OF_MASK (0x01U << TIM3_SR_CC4OF_SHIFT) +#define TIM3_SR_CC4OF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC4OF_SHIFT)) & TIM3_SR_CC4OF_MASK) + +#define TIM3_SR_CC3OF_SHIFT (11) +#define TIM3_SR_CC3OF_MASK (0x01U << TIM3_SR_CC3OF_SHIFT) +#define TIM3_SR_CC3OF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC3OF_SHIFT)) & TIM3_SR_CC3OF_MASK) + +#define TIM3_SR_CC2OF_SHIFT (10) +#define TIM3_SR_CC2OF_MASK (0x01U << TIM3_SR_CC2OF_SHIFT) +#define TIM3_SR_CC2OF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC2OF_SHIFT)) & TIM3_SR_CC2OF_MASK) + +#define TIM3_SR_CC1OF_SHIFT (9) +#define TIM3_SR_CC1OF_MASK (0x01U << TIM3_SR_CC1OF_SHIFT) +#define TIM3_SR_CC1OF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC1OF_SHIFT)) & TIM3_SR_CC1OF_MASK) + +#define TIM3_SR_TIF_SHIFT (6) +#define TIM3_SR_TIF_MASK (0x01U << TIM3_SR_TIF_SHIFT) +#define TIM3_SR_TIF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_TIF_SHIFT)) & TIM3_SR_TIF_MASK) + +#define TIM3_SR_CC4IF_SHIFT (4) +#define TIM3_SR_CC4IF_MASK (0x01U << TIM3_SR_CC4IF_SHIFT) +#define TIM3_SR_CC4IF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC4IF_SHIFT)) & TIM3_SR_CC4IF_MASK) + +#define TIM3_SR_CC3IF_SHIFT (3) +#define TIM3_SR_CC3IF_MASK (0x01U << TIM3_SR_CC3IF_SHIFT) +#define TIM3_SR_CC3IF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC3IF_SHIFT)) & TIM3_SR_CC3IF_MASK) + +#define TIM3_SR_CC2IF_SHIFT (2) +#define TIM3_SR_CC2IF_MASK (0x01U << TIM3_SR_CC2IF_SHIFT) +#define TIM3_SR_CC2IF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC2IF_SHIFT)) & TIM3_SR_CC2IF_MASK) + +#define TIM3_SR_CC1IF_SHIFT (1) +#define TIM3_SR_CC1IF_MASK (0x01U << TIM3_SR_CC1IF_SHIFT) +#define TIM3_SR_CC1IF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_CC1IF_SHIFT)) & TIM3_SR_CC1IF_MASK) + +#define TIM3_SR_UIF_SHIFT (0) +#define TIM3_SR_UIF_MASK (0x01U << TIM3_SR_UIF_SHIFT) +#define TIM3_SR_UIF(x) (((uint32_t)(((uint32_t)(x)) << TIM3_SR_UIF_SHIFT)) & TIM3_SR_UIF_MASK) + +/*! + * @brief TIM3_EGR Register Bit Definition + */ + +#define TIM3_EGR_TG_SHIFT (6) +#define TIM3_EGR_TG_MASK (0x01U << TIM3_EGR_TG_SHIFT) +#define TIM3_EGR_TG(x) (((uint32_t)(((uint32_t)(x)) << TIM3_EGR_TG_SHIFT)) & TIM3_EGR_TG_MASK) + +#define TIM3_EGR_COMG_SHIFT (5) +#define TIM3_EGR_COMG_MASK (0x01U << TIM3_EGR_COMG_SHIFT) +#define TIM3_EGR_COMG(x) (((uint32_t)(((uint32_t)(x)) << TIM3_EGR_COMG_SHIFT)) & TIM3_EGR_COMG_MASK) + +#define TIM3_EGR_CC4G_SHIFT (4) +#define TIM3_EGR_CC4G_MASK (0x01U << TIM3_EGR_CC4G_SHIFT) +#define TIM3_EGR_CC4G(x) (((uint32_t)(((uint32_t)(x)) << TIM3_EGR_CC4G_SHIFT)) & TIM3_EGR_CC4G_MASK) + +#define TIM3_EGR_CC3G_SHIFT (3) +#define TIM3_EGR_CC3G_MASK (0x01U << TIM3_EGR_CC3G_SHIFT) +#define TIM3_EGR_CC3G(x) (((uint32_t)(((uint32_t)(x)) << TIM3_EGR_CC3G_SHIFT)) & TIM3_EGR_CC3G_MASK) + +#define TIM3_EGR_CC2G_SHIFT (2) +#define TIM3_EGR_CC2G_MASK (0x01U << TIM3_EGR_CC2G_SHIFT) +#define TIM3_EGR_CC2G(x) (((uint32_t)(((uint32_t)(x)) << TIM3_EGR_CC2G_SHIFT)) & TIM3_EGR_CC2G_MASK) + +#define TIM3_EGR_CC1G_SHIFT (1) +#define TIM3_EGR_CC1G_MASK (0x01U << TIM3_EGR_CC1G_SHIFT) +#define TIM3_EGR_CC1G(x) (((uint32_t)(((uint32_t)(x)) << TIM3_EGR_CC1G_SHIFT)) & TIM3_EGR_CC1G_MASK) + +#define TIM3_EGR_UG_SHIFT (0) +#define TIM3_EGR_UG_MASK (0x01U << TIM3_EGR_UG_SHIFT) +#define TIM3_EGR_UG(x) (((uint32_t)(((uint32_t)(x)) << TIM3_EGR_UG_SHIFT)) & TIM3_EGR_UG_MASK) + +/*! + * @brief TIM3_CCMR1 Register Bit Definition + */ + +#define TIM3_CCMR1_OC2CE_SHIFT (15) +#define TIM3_CCMR1_OC2CE_MASK (0x01U << TIM3_CCMR1_OC2CE_SHIFT) +#define TIM3_CCMR1_OC2CE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC2CE_SHIFT)) & TIM3_CCMR1_OC2CE_MASK) + +#define TIM3_CCMR1_OC2M_SHIFT (12) +#define TIM3_CCMR1_OC2M_MASK (0x7U << TIM3_CCMR1_OC2M_SHIFT) +#define TIM3_CCMR1_OC2M(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC2M_SHIFT)) & TIM3_CCMR1_OC2M_MASK) + +#define TIM3_CCMR1_OC2PE_SHIFT (11) +#define TIM3_CCMR1_OC2PE_MASK (0x01U << TIM3_CCMR1_OC2PE_SHIFT) +#define TIM3_CCMR1_OC2PE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC2PE_SHIFT)) & TIM3_CCMR1_OC2PE_MASK) + +#define TIM3_CCMR1_OC2FE_SHIFT (10) +#define TIM3_CCMR1_OC2FE_MASK (0x01U << TIM3_CCMR1_OC2FE_SHIFT) +#define TIM3_CCMR1_OC2FE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC2FE_SHIFT)) & TIM3_CCMR1_OC2FE_MASK) + +#define TIM3_CCMR1_CC2S_SHIFT (8) +#define TIM3_CCMR1_CC2S_MASK (0x3U << TIM3_CCMR1_CC2S_SHIFT) +#define TIM3_CCMR1_CC2S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_CC2S_SHIFT)) & TIM3_CCMR1_CC2S_MASK) + +#define TIM3_CCMR1_OC1CE_SHIFT (7) +#define TIM3_CCMR1_OC1CE_MASK (0x01U << TIM3_CCMR1_OC1CE_SHIFT) +#define TIM3_CCMR1_OC1CE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC1CE_SHIFT)) & TIM3_CCMR1_OC1CE_MASK) + +#define TIM3_CCMR1_OC1M_SHIFT (4) +#define TIM3_CCMR1_OC1M_MASK (0x7U << TIM3_CCMR1_OC1M_SHIFT) +#define TIM3_CCMR1_OC1M(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC1M_SHIFT)) & TIM3_CCMR1_OC1M_MASK) + +#define TIM3_CCMR1_OC1PE_SHIFT (3) +#define TIM3_CCMR1_OC1PE_MASK (0x01U << TIM3_CCMR1_OC1PE_SHIFT) +#define TIM3_CCMR1_OC1PE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC1PE_SHIFT)) & TIM3_CCMR1_OC1PE_MASK) + +#define TIM3_CCMR1_OC1FE_SHIFT (2) +#define TIM3_CCMR1_OC1FE_MASK (0x01U << TIM3_CCMR1_OC1FE_SHIFT) +#define TIM3_CCMR1_OC1FE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_OC1FE_SHIFT)) & TIM3_CCMR1_OC1FE_MASK) + +#define TIM3_CCMR1_CC1S_SHIFT (0) +#define TIM3_CCMR1_CC1S_MASK (0x3U << TIM3_CCMR1_CC1S_SHIFT) +#define TIM3_CCMR1_CC1S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_CC1S_SHIFT)) & TIM3_CCMR1_CC1S_MASK) + +/*! + * @brief TIM3_CCMR1 Register Bit Definition + */ + +#define TIM3_CCMR1_IC2F_SHIFT (12) +#define TIM3_CCMR1_IC2F_MASK (0xFU << TIM3_CCMR1_IC2F_SHIFT) +#define TIM3_CCMR1_IC2F(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_IC2F_SHIFT)) & TIM3_CCMR1_IC2F_MASK) + +#define TIM3_CCMR1_IC2PSC_SHIFT (10) +#define TIM3_CCMR1_IC2PSC_MASK (0x3U << TIM3_CCMR1_IC2PSC_SHIFT) +#define TIM3_CCMR1_IC2PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_IC2PSC_SHIFT)) & TIM3_CCMR1_IC2PSC_MASK) + +#define TIM3_CCMR1_CC2S_SHIFT (8) +#define TIM3_CCMR1_CC2S_MASK (0x3U << TIM3_CCMR1_CC2S_SHIFT) +#define TIM3_CCMR1_CC2S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_CC2S_SHIFT)) & TIM3_CCMR1_CC2S_MASK) + +#define TIM3_CCMR1_IC1F_SHIFT (4) +#define TIM3_CCMR1_IC1F_MASK (0xFU << TIM3_CCMR1_IC1F_SHIFT) +#define TIM3_CCMR1_IC1F(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_IC1F_SHIFT)) & TIM3_CCMR1_IC1F_MASK) + +#define TIM3_CCMR1_IC1PSC_SHIFT (2) +#define TIM3_CCMR1_IC1PSC_MASK (0x3U << TIM3_CCMR1_IC1PSC_SHIFT) +#define TIM3_CCMR1_IC1PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_IC1PSC_SHIFT)) & TIM3_CCMR1_IC1PSC_MASK) + +#define TIM3_CCMR1_CC1S_SHIFT (0) +#define TIM3_CCMR1_CC1S_MASK (0x3U << TIM3_CCMR1_CC1S_SHIFT) +#define TIM3_CCMR1_CC1S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR1_CC1S_SHIFT)) & TIM3_CCMR1_CC1S_MASK) + +/*! + * @brief TIM3_CCMR2 Register Bit Definition + */ + +#define TIM3_CCMR2_OC4CE_SHIFT (15) +#define TIM3_CCMR2_OC4CE_MASK (0x01U << TIM3_CCMR2_OC4CE_SHIFT) +#define TIM3_CCMR2_OC4CE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC4CE_SHIFT)) & TIM3_CCMR2_OC4CE_MASK) + +#define TIM3_CCMR2_OC4M_SHIFT (12) +#define TIM3_CCMR2_OC4M_MASK (0x7U << TIM3_CCMR2_OC4M_SHIFT) +#define TIM3_CCMR2_OC4M(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC4M_SHIFT)) & TIM3_CCMR2_OC4M_MASK) + +#define TIM3_CCMR2_OC4PE_SHIFT (11) +#define TIM3_CCMR2_OC4PE_MASK (0x01U << TIM3_CCMR2_OC4PE_SHIFT) +#define TIM3_CCMR2_OC4PE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC4PE_SHIFT)) & TIM3_CCMR2_OC4PE_MASK) + +#define TIM3_CCMR2_OC4FE_SHIFT (10) +#define TIM3_CCMR2_OC4FE_MASK (0x01U << TIM3_CCMR2_OC4FE_SHIFT) +#define TIM3_CCMR2_OC4FE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC4FE_SHIFT)) & TIM3_CCMR2_OC4FE_MASK) + +#define TIM3_CCMR2_CC4S_SHIFT (8) +#define TIM3_CCMR2_CC4S_MASK (0x3U << TIM3_CCMR2_CC4S_SHIFT) +#define TIM3_CCMR2_CC4S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_CC4S_SHIFT)) & TIM3_CCMR2_CC4S_MASK) + +#define TIM3_CCMR2_OC3CE_SHIFT (7) +#define TIM3_CCMR2_OC3CE_MASK (0x01U << TIM3_CCMR2_OC3CE_SHIFT) +#define TIM3_CCMR2_OC3CE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC3CE_SHIFT)) & TIM3_CCMR2_OC3CE_MASK) + +#define TIM3_CCMR2_OC3M_SHIFT (4) +#define TIM3_CCMR2_OC3M_MASK (0x7U << TIM3_CCMR2_OC3M_SHIFT) +#define TIM3_CCMR2_OC3M(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC3M_SHIFT)) & TIM3_CCMR2_OC3M_MASK) + +#define TIM3_CCMR2_OC3PE_SHIFT (3) +#define TIM3_CCMR2_OC3PE_MASK (0x01U << TIM3_CCMR2_OC3PE_SHIFT) +#define TIM3_CCMR2_OC3PE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC3PE_SHIFT)) & TIM3_CCMR2_OC3PE_MASK) + +#define TIM3_CCMR2_OC3FE_SHIFT (2) +#define TIM3_CCMR2_OC3FE_MASK (0x01U << TIM3_CCMR2_OC3FE_SHIFT) +#define TIM3_CCMR2_OC3FE(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_OC3FE_SHIFT)) & TIM3_CCMR2_OC3FE_MASK) + +#define TIM3_CCMR2_CC3S_SHIFT (0) +#define TIM3_CCMR2_CC3S_MASK (0x3U << TIM3_CCMR2_CC3S_SHIFT) +#define TIM3_CCMR2_CC3S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_CC3S_SHIFT)) & TIM3_CCMR2_CC3S_MASK) + +/*! + * @brief TIM3_CCMR2 Register Bit Definition + */ + +#define TIM3_CCMR2_IC4F_SHIFT (12) +#define TIM3_CCMR2_IC4F_MASK (0xFU << TIM3_CCMR2_IC4F_SHIFT) +#define TIM3_CCMR2_IC4F(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_IC4F_SHIFT)) & TIM3_CCMR2_IC4F_MASK) + +#define TIM3_CCMR2_IC4PSC_SHIFT (10) +#define TIM3_CCMR2_IC4PSC_MASK (0x3U << TIM3_CCMR2_IC4PSC_SHIFT) +#define TIM3_CCMR2_IC4PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_IC4PSC_SHIFT)) & TIM3_CCMR2_IC4PSC_MASK) + +#define TIM3_CCMR2_CC4S_SHIFT (8) +#define TIM3_CCMR2_CC4S_MASK (0x3U << TIM3_CCMR2_CC4S_SHIFT) +#define TIM3_CCMR2_CC4S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_CC4S_SHIFT)) & TIM3_CCMR2_CC4S_MASK) + +#define TIM3_CCMR2_IC3F_SHIFT (4) +#define TIM3_CCMR2_IC3F_MASK (0xFU << TIM3_CCMR2_IC3F_SHIFT) +#define TIM3_CCMR2_IC3F(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_IC3F_SHIFT)) & TIM3_CCMR2_IC3F_MASK) + +#define TIM3_CCMR2_IC3PSC_SHIFT (2) +#define TIM3_CCMR2_IC3PSC_MASK (0x3U << TIM3_CCMR2_IC3PSC_SHIFT) +#define TIM3_CCMR2_IC3PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_IC3PSC_SHIFT)) & TIM3_CCMR2_IC3PSC_MASK) + +#define TIM3_CCMR2_CC3S_SHIFT (0) +#define TIM3_CCMR2_CC3S_MASK (0x3U << TIM3_CCMR2_CC3S_SHIFT) +#define TIM3_CCMR2_CC3S(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCMR2_CC3S_SHIFT)) & TIM3_CCMR2_CC3S_MASK) + +/*! + * @brief TIM3_CCER Register Bit Definition + */ + +#define TIM3_CCER_CC4NP_SHIFT (15) +#define TIM3_CCER_CC4NP_MASK (0x01U << TIM3_CCER_CC4NP_SHIFT) +#define TIM3_CCER_CC4NP(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC4NP_SHIFT)) & TIM3_CCER_CC4NP_MASK) + +#define TIM3_CCER_CC4P_SHIFT (13) +#define TIM3_CCER_CC4P_MASK (0x01U << TIM3_CCER_CC4P_SHIFT) +#define TIM3_CCER_CC4P(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC4P_SHIFT)) & TIM3_CCER_CC4P_MASK) + +#define TIM3_CCER_CC4E_SHIFT (12) +#define TIM3_CCER_CC4E_MASK (0x01U << TIM3_CCER_CC4E_SHIFT) +#define TIM3_CCER_CC4E(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC4E_SHIFT)) & TIM3_CCER_CC4E_MASK) + +#define TIM3_CCER_CC3NP_SHIFT (11) +#define TIM3_CCER_CC3NP_MASK (0x01U << TIM3_CCER_CC3NP_SHIFT) +#define TIM3_CCER_CC3NP(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC3NP_SHIFT)) & TIM3_CCER_CC3NP_MASK) + +#define TIM3_CCER_CC3P_SHIFT (9) +#define TIM3_CCER_CC3P_MASK (0x01U << TIM3_CCER_CC3P_SHIFT) +#define TIM3_CCER_CC3P(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC3P_SHIFT)) & TIM3_CCER_CC3P_MASK) + +#define TIM3_CCER_CC3E_SHIFT (8) +#define TIM3_CCER_CC3E_MASK (0x01U << TIM3_CCER_CC3E_SHIFT) +#define TIM3_CCER_CC3E(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC3E_SHIFT)) & TIM3_CCER_CC3E_MASK) + +#define TIM3_CCER_CC2NP_SHIFT (7) +#define TIM3_CCER_CC2NP_MASK (0x01U << TIM3_CCER_CC2NP_SHIFT) +#define TIM3_CCER_CC2NP(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC2NP_SHIFT)) & TIM3_CCER_CC2NP_MASK) + +#define TIM3_CCER_CC2P_SHIFT (5) +#define TIM3_CCER_CC2P_MASK (0x01U << TIM3_CCER_CC2P_SHIFT) +#define TIM3_CCER_CC2P(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC2P_SHIFT)) & TIM3_CCER_CC2P_MASK) + +#define TIM3_CCER_CC2E_SHIFT (4) +#define TIM3_CCER_CC2E_MASK (0x01U << TIM3_CCER_CC2E_SHIFT) +#define TIM3_CCER_CC2E(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC2E_SHIFT)) & TIM3_CCER_CC2E_MASK) + +#define TIM3_CCER_CC1NP_SHIFT (3) +#define TIM3_CCER_CC1NP_MASK (0x01U << TIM3_CCER_CC1NP_SHIFT) +#define TIM3_CCER_CC1NP(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC1NP_SHIFT)) & TIM3_CCER_CC1NP_MASK) + +#define TIM3_CCER_CC1P_SHIFT (1) +#define TIM3_CCER_CC1P_MASK (0x01U << TIM3_CCER_CC1P_SHIFT) +#define TIM3_CCER_CC1P(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC1P_SHIFT)) & TIM3_CCER_CC1P_MASK) + +#define TIM3_CCER_CC1E_SHIFT (0) +#define TIM3_CCER_CC1E_MASK (0x01U << TIM3_CCER_CC1E_SHIFT) +#define TIM3_CCER_CC1E(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCER_CC1E_SHIFT)) & TIM3_CCER_CC1E_MASK) + +/*! + * @brief TIM3_CNT Register Bit Definition + */ + +#define TIM3_CNT_CNT_SHIFT (0) +#define TIM3_CNT_CNT_MASK (0xFFFFU << TIM3_CNT_CNT_SHIFT) +#define TIM3_CNT_CNT(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CNT_CNT_SHIFT)) & TIM3_CNT_CNT_MASK) + +/*! + * @brief TIM3_PSC Register Bit Definition + */ + +#define TIM3_PSC_PSC_SHIFT (0) +#define TIM3_PSC_PSC_MASK (0xFFFFU << TIM3_PSC_PSC_SHIFT) +#define TIM3_PSC_PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM3_PSC_PSC_SHIFT)) & TIM3_PSC_PSC_MASK) + +/*! + * @brief TIM3_ARR Register Bit Definition + */ + +#define TIM3_ARR_ARR_SHIFT (0) +#define TIM3_ARR_ARR_MASK (0xFFFFU << TIM3_ARR_ARR_SHIFT) +#define TIM3_ARR_ARR(x) (((uint32_t)(((uint32_t)(x)) << TIM3_ARR_ARR_SHIFT)) & TIM3_ARR_ARR_MASK) + +/*! + * @brief TIM3_CCR1 Register Bit Definition + */ + +#define TIM3_CCR1_CCR1_SHIFT (0) +#define TIM3_CCR1_CCR1_MASK (0xFFFFU << TIM3_CCR1_CCR1_SHIFT) +#define TIM3_CCR1_CCR1(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCR1_CCR1_SHIFT)) & TIM3_CCR1_CCR1_MASK) + +/*! + * @brief TIM3_CCR2 Register Bit Definition + */ + +#define TIM3_CCR2_CCR2_SHIFT (0) +#define TIM3_CCR2_CCR2_MASK (0xFFFFU << TIM3_CCR2_CCR2_SHIFT) +#define TIM3_CCR2_CCR2(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCR2_CCR2_SHIFT)) & TIM3_CCR2_CCR2_MASK) + +/*! + * @brief TIM3_CCR3 Register Bit Definition + */ + +#define TIM3_CCR3_CCR3_SHIFT (0) +#define TIM3_CCR3_CCR3_MASK (0xFFFFU << TIM3_CCR3_CCR3_SHIFT) +#define TIM3_CCR3_CCR3(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCR3_CCR3_SHIFT)) & TIM3_CCR3_CCR3_MASK) + +/*! + * @brief TIM3_CCR4 Register Bit Definition + */ + +#define TIM3_CCR4_CCR4_SHIFT (0) +#define TIM3_CCR4_CCR4_MASK (0xFFFFU << TIM3_CCR4_CCR4_SHIFT) +#define TIM3_CCR4_CCR4(x) (((uint32_t)(((uint32_t)(x)) << TIM3_CCR4_CCR4_SHIFT)) & TIM3_CCR4_CCR4_MASK) + +/*! + * @brief TIM3_DCR Register Bit Definition + */ + +#define TIM3_DCR_DBL_SHIFT (8) +#define TIM3_DCR_DBL_MASK (0x1FU << TIM3_DCR_DBL_SHIFT) +#define TIM3_DCR_DBL(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DCR_DBL_SHIFT)) & TIM3_DCR_DBL_MASK) + +#define TIM3_DCR_DBA_SHIFT (0) +#define TIM3_DCR_DBA_MASK (0x1FU << TIM3_DCR_DBA_SHIFT) +#define TIM3_DCR_DBA(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DCR_DBA_SHIFT)) & TIM3_DCR_DBA_MASK) + +/*! + * @brief TIM3_DMAR Register Bit Definition + */ + +#define TIM3_DMAR_DMAB_SHIFT (0) +#define TIM3_DMAR_DMAB_MASK (0xFFFFU << TIM3_DMAR_DMAB_SHIFT) +#define TIM3_DMAR_DMAB(x) (((uint32_t)(((uint32_t)(x)) << TIM3_DMAR_DMAB_SHIFT)) & TIM3_DMAR_DMAB_MASK) + +/*! + * @} + */ /* end of group TIM3_Register_Masks */ +/****************************************************************************** + * TIM3/4 Instance +******************************************************************************/ +#define TIM3 ((TIM3_Type*)TIM3_BASE) +#define TIM4 ((TIM3_Type*)TIM4_BASE) + +/*! + * @} + */ /* end of group TIM3_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup TIM2_Peripheral_Access_Layer TIM2 Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * TIM2 Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR1; ///< Control register 1 offset: 0x00 + __IO uint32_t CR2; ///< Control register 2 offset: 0x04 + __IO uint32_t SMCR; ///< Slave mode control register offset: 0x08 + __IO uint32_t DIER; ///< DMA/interrupt enable register offset: 0x0C + __IO uint32_t SR; ///< Status register offset: 0x10 + __IO uint32_t EGR; ///< Event generation register offset: 0x14 + __IO uint32_t CCMR1; ///< offset: 0x18 + __IO uint32_t CCMR2; ///< offset: 0x1C + __IO uint32_t CCER; ///< Capture/compare enable register offset: 0x20 + __IO uint32_t CNT; ///< Counter offset: 0x24 + __IO uint32_t PSC; ///< Prescaler offset: 0x28 + __IO uint32_t ARR; ///< Autoload register offset: 0x2C + __IO uint32_t Reserved10[1]; ///< Reserved + __IO uint32_t CCR[4]; +// __IO uint32_t CCR1; ///< Capture/compare register 1 offset: 0x34 +// __IO uint32_t CCR2; ///< Capture/compare register 2 offset: 0x38 +// __IO uint32_t CCR3; ///< Capture/compare register 3 offset: 0x3C +// __IO uint32_t CCR4; ///< Capture/compare register 4 offset: 0x40 + __IO uint32_t Reserved11[1]; ///< Reserved + __IO uint32_t DCR; ///< DMA control register offset: 0x48 + __IO uint32_t DMAR; ///< DMA address in continuous mode offset: 0x4C + __IO uint32_t OR; ///< TIMERx option register offset: 0x50 +} TIM2_Type; + +/******************************************************************************* + * TIM2 Type + ******************************************************************************/ + +/*! + * @addtogroup TIM2_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM2_CR1 Register Bit Definition + */ + +#define TIM2_CR1_CKD_SHIFT (8) +#define TIM2_CR1_CKD_MASK (0x3U << TIM2_CR1_CKD_SHIFT) +#define TIM2_CR1_CKD(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_CKD_SHIFT)) & TIM2_CR1_CKD_MASK) + +#define TIM2_CR1_APRE_SHIFT (7) +#define TIM2_CR1_APRE_MASK (0x01U << TIM2_CR1_APRE_SHIFT) +#define TIM2_CR1_APRE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_APRE_SHIFT)) & TIM2_CR1_APRE_MASK) + +#define TIM2_CR1_CMS_SHIFT (5) +#define TIM2_CR1_CMS_MASK (0x3U << TIM2_CR1_CMS_SHIFT) +#define TIM2_CR1_CMS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_CMS_SHIFT)) & TIM2_CR1_CMS_MASK) + +#define TIM2_CR1_DIR_SHIFT (4) +#define TIM2_CR1_DIR_MASK (0x01U << TIM2_CR1_DIR_SHIFT) +#define TIM2_CR1_DIR(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_DIR_SHIFT)) & TIM2_CR1_DIR_MASK) + +#define TIM2_CR1_OPM_SHIFT (3) +#define TIM2_CR1_OPM_MASK (0x01U << TIM2_CR1_OPM_SHIFT) +#define TIM2_CR1_OPM(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_OPM_SHIFT)) & TIM2_CR1_OPM_MASK) + +#define TIM2_CR1_URS_SHIFT (2) +#define TIM2_CR1_URS_MASK (0x01U << TIM2_CR1_URS_SHIFT) +#define TIM2_CR1_URS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_URS_SHIFT)) & TIM2_CR1_URS_MASK) + +#define TIM2_CR1_UDIS_SHIFT (1) +#define TIM2_CR1_UDIS_MASK (0x01U << TIM2_CR1_UDIS_SHIFT) +#define TIM2_CR1_UDIS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_UDIS_SHIFT)) & TIM2_CR1_UDIS_MASK) + +#define TIM2_CR1_CEN_SHIFT (0) +#define TIM2_CR1_CEN_MASK (0x01U << TIM2_CR1_CEN_SHIFT) +#define TIM2_CR1_CEN(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR1_CEN_SHIFT)) & TIM2_CR1_CEN_MASK) + +/*! + * @brief TIM2_CR2 Register Bit Definition + */ + +#define TIM2_CR2_TI1S_SHIFT (7) +#define TIM2_CR2_TI1S_MASK (0x01U << TIM2_CR2_TI1S_SHIFT) +#define TIM2_CR2_TI1S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR2_TI1S_SHIFT)) & TIM2_CR2_TI1S_MASK) + +#define TIM2_CR2_MMS_SHIFT (4) +#define TIM2_CR2_MMS_MASK (0x7U << TIM2_CR2_MMS_SHIFT) +#define TIM2_CR2_MMS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR2_MMS_SHIFT)) & TIM2_CR2_MMS_MASK) + +#define TIM2_CR2_CCDS_SHIFT (3) +#define TIM2_CR2_CCDS_MASK (0x01U << TIM2_CR2_CCDS_SHIFT) +#define TIM2_CR2_CCDS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CR2_CCDS_SHIFT)) & TIM2_CR2_CCDS_MASK) + +/*! + * @brief TIM2_SMCR Register Bit Definition + */ + +#define TIM2_SMCR_ETP_SHIFT (15) +#define TIM2_SMCR_ETP_MASK (0x01U << TIM2_SMCR_ETP_SHIFT) +#define TIM2_SMCR_ETP(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_ETP_SHIFT)) & TIM2_SMCR_ETP_MASK) + +#define TIM2_SMCR_ECE_SHIFT (14) +#define TIM2_SMCR_ECE_MASK (0x01U << TIM2_SMCR_ECE_SHIFT) +#define TIM2_SMCR_ECE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_ECE_SHIFT)) & TIM2_SMCR_ECE_MASK) + +#define TIM2_SMCR_ETPS_SHIFT (12) +#define TIM2_SMCR_ETPS_MASK (0x3U << TIM2_SMCR_ETPS_SHIFT) +#define TIM2_SMCR_ETPS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_ETPS_SHIFT)) & TIM2_SMCR_ETPS_MASK) + +#define TIM2_SMCR_ETF_SHIFT (8) +#define TIM2_SMCR_ETF_MASK (0xFU << TIM2_SMCR_ETF_SHIFT) +#define TIM2_SMCR_ETF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_ETF_SHIFT)) & TIM2_SMCR_ETF_MASK) + +#define TIM2_SMCR_MSM_SHIFT (7) +#define TIM2_SMCR_MSM_MASK (0x01U << TIM2_SMCR_MSM_SHIFT) +#define TIM2_SMCR_MSM(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_MSM_SHIFT)) & TIM2_SMCR_MSM_MASK) + +#define TIM2_SMCR_TS_SHIFT (4) +#define TIM2_SMCR_TS_MASK (0x7U << TIM2_SMCR_TS_SHIFT) +#define TIM2_SMCR_TS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_TS_SHIFT)) & TIM2_SMCR_TS_MASK) + +#define TIM2_SMCR_OCCS_SHIFT (3) +#define TIM2_SMCR_OCCS_MASK (0x01U << TIM2_SMCR_OCCS_SHIFT) +#define TIM2_SMCR_OCCS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_OCCS_SHIFT)) & TIM2_SMCR_OCCS_MASK) + +#define TIM2_SMCR_SMS_SHIFT (0) +#define TIM2_SMCR_SMS_MASK (0x7U << TIM2_SMCR_SMS_SHIFT) +#define TIM2_SMCR_SMS(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SMCR_SMS_SHIFT)) & TIM2_SMCR_SMS_MASK) + +/*! + * @brief TIM2_DIER Register Bit Definition + */ + +#define TIM2_DIER_TDE_SHIFT (14) +#define TIM2_DIER_TDE_MASK (0x01U << TIM2_DIER_TDE_SHIFT) +#define TIM2_DIER_TDE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_TDE_SHIFT)) & TIM2_DIER_TDE_MASK) + +#define TIM2_DIER_CC4DE_SHIFT (12) +#define TIM2_DIER_CC4DE_MASK (0x01U << TIM2_DIER_CC4DE_SHIFT) +#define TIM2_DIER_CC4DE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC4DE_SHIFT)) & TIM2_DIER_CC4DE_MASK) + +#define TIM2_DIER_CC3DE_SHIFT (11) +#define TIM2_DIER_CC3DE_MASK (0x01U << TIM2_DIER_CC3DE_SHIFT) +#define TIM2_DIER_CC3DE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC3DE_SHIFT)) & TIM2_DIER_CC3DE_MASK) + +#define TIM2_DIER_CC2DE_SHIFT (10) +#define TIM2_DIER_CC2DE_MASK (0x01U << TIM2_DIER_CC2DE_SHIFT) +#define TIM2_DIER_CC2DE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC2DE_SHIFT)) & TIM2_DIER_CC2DE_MASK) + +#define TIM2_DIER_CC1DE_SHIFT (9) +#define TIM2_DIER_CC1DE_MASK (0x01U << TIM2_DIER_CC1DE_SHIFT) +#define TIM2_DIER_CC1DE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC1DE_SHIFT)) & TIM2_DIER_CC1DE_MASK) + +#define TIM2_DIER_UDE_SHIFT (8) +#define TIM2_DIER_UDE_MASK (0x01U << TIM2_DIER_UDE_SHIFT) +#define TIM2_DIER_UDE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_UDE_SHIFT)) & TIM2_DIER_UDE_MASK) + +#define TIM2_DIER_TIE_SHIFT (6) +#define TIM2_DIER_TIE_MASK (0x01U << TIM2_DIER_TIE_SHIFT) +#define TIM2_DIER_TIE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_TIE_SHIFT)) & TIM2_DIER_TIE_MASK) + +#define TIM2_DIER_CC4IE_SHIFT (4) +#define TIM2_DIER_CC4IE_MASK (0x01U << TIM2_DIER_CC4IE_SHIFT) +#define TIM2_DIER_CC4IE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC4IE_SHIFT)) & TIM2_DIER_CC4IE_MASK) + +#define TIM2_DIER_CC3IE_SHIFT (3) +#define TIM2_DIER_CC3IE_MASK (0x01U << TIM2_DIER_CC3IE_SHIFT) +#define TIM2_DIER_CC3IE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC3IE_SHIFT)) & TIM2_DIER_CC3IE_MASK) + +#define TIM2_DIER_CC2IE_SHIFT (2) +#define TIM2_DIER_CC2IE_MASK (0x01U << TIM2_DIER_CC2IE_SHIFT) +#define TIM2_DIER_CC2IE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC2IE_SHIFT)) & TIM2_DIER_CC2IE_MASK) + +#define TIM2_DIER_CC1IE_SHIFT (1) +#define TIM2_DIER_CC1IE_MASK (0x01U << TIM2_DIER_CC1IE_SHIFT) +#define TIM2_DIER_CC1IE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_CC1IE_SHIFT)) & TIM2_DIER_CC1IE_MASK) + +#define TIM2_DIER_UIE_SHIFT (0) +#define TIM2_DIER_UIE_MASK (0x01U << TIM2_DIER_UIE_SHIFT) +#define TIM2_DIER_UIE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DIER_UIE_SHIFT)) & TIM2_DIER_UIE_MASK) + +/*! + * @brief TIM2_SR Register Bit Definition + */ + +#define TIM2_SR_CC4OF_SHIFT (12) +#define TIM2_SR_CC4OF_MASK (0x01U << TIM2_SR_CC4OF_SHIFT) +#define TIM2_SR_CC4OF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC4OF_SHIFT)) & TIM2_SR_CC4OF_MASK) + +#define TIM2_SR_CC3OF_SHIFT (11) +#define TIM2_SR_CC3OF_MASK (0x01U << TIM2_SR_CC3OF_SHIFT) +#define TIM2_SR_CC3OF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC3OF_SHIFT)) & TIM2_SR_CC3OF_MASK) + +#define TIM2_SR_CC2OF_SHIFT (10) +#define TIM2_SR_CC2OF_MASK (0x01U << TIM2_SR_CC2OF_SHIFT) +#define TIM2_SR_CC2OF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC2OF_SHIFT)) & TIM2_SR_CC2OF_MASK) + +#define TIM2_SR_CC1OF_SHIFT (9) +#define TIM2_SR_CC1OF_MASK (0x01U << TIM2_SR_CC1OF_SHIFT) +#define TIM2_SR_CC1OF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC1OF_SHIFT)) & TIM2_SR_CC1OF_MASK) + +#define TIM2_SR_TIF_SHIFT (6) +#define TIM2_SR_TIF_MASK (0x01U << TIM2_SR_TIF_SHIFT) +#define TIM2_SR_TIF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_TIF_SHIFT)) & TIM2_SR_TIF_MASK) + +#define TIM2_SR_CC4IF_SHIFT (4) +#define TIM2_SR_CC4IF_MASK (0x01U << TIM2_SR_CC4IF_SHIFT) +#define TIM2_SR_CC4IF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC4IF_SHIFT)) & TIM2_SR_CC4IF_MASK) + +#define TIM2_SR_CC3IF_SHIFT (3) +#define TIM2_SR_CC3IF_MASK (0x01U << TIM2_SR_CC3IF_SHIFT) +#define TIM2_SR_CC3IF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC3IF_SHIFT)) & TIM2_SR_CC3IF_MASK) + +#define TIM2_SR_CC2IF_SHIFT (2) +#define TIM2_SR_CC2IF_MASK (0x01U << TIM2_SR_CC2IF_SHIFT) +#define TIM2_SR_CC2IF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC2IF_SHIFT)) & TIM2_SR_CC2IF_MASK) + +#define TIM2_SR_CC1IF_SHIFT (1) +#define TIM2_SR_CC1IF_MASK (0x01U << TIM2_SR_CC1IF_SHIFT) +#define TIM2_SR_CC1IF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_CC1IF_SHIFT)) & TIM2_SR_CC1IF_MASK) + +#define TIM2_SR_UIF_SHIFT (0) +#define TIM2_SR_UIF_MASK (0x01U << TIM2_SR_UIF_SHIFT) +#define TIM2_SR_UIF(x) (((uint32_t)(((uint32_t)(x)) << TIM2_SR_UIF_SHIFT)) & TIM2_SR_UIF_MASK) + +/*! + * @brief TIM2_EGR Register Bit Definition + */ + +#define TIM2_EGR_TG_SHIFT (6) +#define TIM2_EGR_TG_MASK (0x01U << TIM2_EGR_TG_SHIFT) +#define TIM2_EGR_TG(x) (((uint32_t)(((uint32_t)(x)) << TIM2_EGR_TG_SHIFT)) & TIM2_EGR_TG_MASK) + +#define TIM2_EGR_COMG_SHIFT (5) +#define TIM2_EGR_COMG_MASK (0x01U << TIM2_EGR_COMG_SHIFT) +#define TIM2_EGR_COMG(x) (((uint32_t)(((uint32_t)(x)) << TIM2_EGR_COMG_SHIFT)) & TIM2_EGR_COMG_MASK) + +#define TIM2_EGR_CC4G_SHIFT (4) +#define TIM2_EGR_CC4G_MASK (0x01U << TIM2_EGR_CC4G_SHIFT) +#define TIM2_EGR_CC4G(x) (((uint32_t)(((uint32_t)(x)) << TIM2_EGR_CC4G_SHIFT)) & TIM2_EGR_CC4G_MASK) + +#define TIM2_EGR_CC3G_SHIFT (3) +#define TIM2_EGR_CC3G_MASK (0x01U << TIM2_EGR_CC3G_SHIFT) +#define TIM2_EGR_CC3G(x) (((uint32_t)(((uint32_t)(x)) << TIM2_EGR_CC3G_SHIFT)) & TIM2_EGR_CC3G_MASK) + +#define TIM2_EGR_CC2G_SHIFT (2) +#define TIM2_EGR_CC2G_MASK (0x01U << TIM2_EGR_CC2G_SHIFT) +#define TIM2_EGR_CC2G(x) (((uint32_t)(((uint32_t)(x)) << TIM2_EGR_CC2G_SHIFT)) & TIM2_EGR_CC2G_MASK) + +#define TIM2_EGR_CC1G_SHIFT (1) +#define TIM2_EGR_CC1G_MASK (0x01U << TIM2_EGR_CC1G_SHIFT) +#define TIM2_EGR_CC1G(x) (((uint32_t)(((uint32_t)(x)) << TIM2_EGR_CC1G_SHIFT)) & TIM2_EGR_CC1G_MASK) + +#define TIM2_EGR_UG_SHIFT (0) +#define TIM2_EGR_UG_MASK (0x01U << TIM2_EGR_UG_SHIFT) +#define TIM2_EGR_UG(x) (((uint32_t)(((uint32_t)(x)) << TIM2_EGR_UG_SHIFT)) & TIM2_EGR_UG_MASK) + +/*! + * @brief TIM2_CCMR1 Register Bit Definition + */ + +#define TIM2_CCMR1_OC2CE_SHIFT (15) +#define TIM2_CCMR1_OC2CE_MASK (0x01U << TIM2_CCMR1_OC2CE_SHIFT) +#define TIM2_CCMR1_OC2CE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC2CE_SHIFT)) & TIM2_CCMR1_OC2CE_MASK) + +#define TIM2_CCMR1_OC2M_SHIFT (12) +#define TIM2_CCMR1_OC2M_MASK (0x7U << TIM2_CCMR1_OC2M_SHIFT) +#define TIM2_CCMR1_OC2M(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC2M_SHIFT)) & TIM2_CCMR1_OC2M_MASK) + +#define TIM2_CCMR1_OC2PE_SHIFT (11) +#define TIM2_CCMR1_OC2PE_MASK (0x01U << TIM2_CCMR1_OC2PE_SHIFT) +#define TIM2_CCMR1_OC2PE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC2PE_SHIFT)) & TIM2_CCMR1_OC2PE_MASK) + +#define TIM2_CCMR1_OC2FE_SHIFT (10) +#define TIM2_CCMR1_OC2FE_MASK (0x01U << TIM2_CCMR1_OC2FE_SHIFT) +#define TIM2_CCMR1_OC2FE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC2FE_SHIFT)) & TIM2_CCMR1_OC2FE_MASK) + +#define TIM2_CCMR1_CC2S_SHIFT (8) +#define TIM2_CCMR1_CC2S_MASK (0x3U << TIM2_CCMR1_CC2S_SHIFT) +#define TIM2_CCMR1_CC2S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_CC2S_SHIFT)) & TIM2_CCMR1_CC2S_MASK) + +#define TIM2_CCMR1_OC1CE_SHIFT (7) +#define TIM2_CCMR1_OC1CE_MASK (0x01U << TIM2_CCMR1_OC1CE_SHIFT) +#define TIM2_CCMR1_OC1CE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC1CE_SHIFT)) & TIM2_CCMR1_OC1CE_MASK) + +#define TIM2_CCMR1_OC1M_SHIFT (4) +#define TIM2_CCMR1_OC1M_MASK (0x7U << TIM2_CCMR1_OC1M_SHIFT) +#define TIM2_CCMR1_OC1M(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC1M_SHIFT)) & TIM2_CCMR1_OC1M_MASK) + +#define TIM2_CCMR1_OC1PE_SHIFT (3) +#define TIM2_CCMR1_OC1PE_MASK (0x01U << TIM2_CCMR1_OC1PE_SHIFT) +#define TIM2_CCMR1_OC1PE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC1PE_SHIFT)) & TIM2_CCMR1_OC1PE_MASK) + +#define TIM2_CCMR1_OC1FE_SHIFT (2) +#define TIM2_CCMR1_OC1FE_MASK (0x01U << TIM2_CCMR1_OC1FE_SHIFT) +#define TIM2_CCMR1_OC1FE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_OC1FE_SHIFT)) & TIM2_CCMR1_OC1FE_MASK) + +#define TIM2_CCMR1_CC1S_SHIFT (0) +#define TIM2_CCMR1_CC1S_MASK (0x3U << TIM2_CCMR1_CC1S_SHIFT) +#define TIM2_CCMR1_CC1S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_CC1S_SHIFT)) & TIM2_CCMR1_CC1S_MASK) + +/*! + * @brief TIM2_CCMR1 Register Bit Definition + */ + +#define TIM2_CCMR1_IC2F_SHIFT (12) +#define TIM2_CCMR1_IC2F_MASK (0xFU << TIM2_CCMR1_IC2F_SHIFT) +#define TIM2_CCMR1_IC2F(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_IC2F_SHIFT)) & TIM2_CCMR1_IC2F_MASK) + +#define TIM2_CCMR1_IC2PSC_SHIFT (10) +#define TIM2_CCMR1_IC2PSC_MASK (0x3U << TIM2_CCMR1_IC2PSC_SHIFT) +#define TIM2_CCMR1_IC2PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_IC2PSC_SHIFT)) & TIM2_CCMR1_IC2PSC_MASK) + +#define TIM2_CCMR1_CC2S_SHIFT (8) +#define TIM2_CCMR1_CC2S_MASK (0x3U << TIM2_CCMR1_CC2S_SHIFT) +#define TIM2_CCMR1_CC2S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_CC2S_SHIFT)) & TIM2_CCMR1_CC2S_MASK) + +#define TIM2_CCMR1_IC1F_SHIFT (4) +#define TIM2_CCMR1_IC1F_MASK (0xFU << TIM2_CCMR1_IC1F_SHIFT) +#define TIM2_CCMR1_IC1F(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_IC1F_SHIFT)) & TIM2_CCMR1_IC1F_MASK) + +#define TIM2_CCMR1_IC1PSC_SHIFT (2) +#define TIM2_CCMR1_IC1PSC_MASK (0x3U << TIM2_CCMR1_IC1PSC_SHIFT) +#define TIM2_CCMR1_IC1PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_IC1PSC_SHIFT)) & TIM2_CCMR1_IC1PSC_MASK) + +#define TIM2_CCMR1_CC1S_SHIFT (0) +#define TIM2_CCMR1_CC1S_MASK (0x3U << TIM2_CCMR1_CC1S_SHIFT) +#define TIM2_CCMR1_CC1S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR1_CC1S_SHIFT)) & TIM2_CCMR1_CC1S_MASK) + +/*! + * @brief TIM2_CCMR2 Register Bit Definition + */ + +#define TIM2_CCMR2_OC4CE_SHIFT (15) +#define TIM2_CCMR2_OC4CE_MASK (0x01U << TIM2_CCMR2_OC4CE_SHIFT) +#define TIM2_CCMR2_OC4CE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC4CE_SHIFT)) & TIM2_CCMR2_OC4CE_MASK) + +#define TIM2_CCMR2_OC4M_SHIFT (12) +#define TIM2_CCMR2_OC4M_MASK (0x7U << TIM2_CCMR2_OC4M_SHIFT) +#define TIM2_CCMR2_OC4M(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC4M_SHIFT)) & TIM2_CCMR2_OC4M_MASK) + +#define TIM2_CCMR2_OC4PE_SHIFT (11) +#define TIM2_CCMR2_OC4PE_MASK (0x01U << TIM2_CCMR2_OC4PE_SHIFT) +#define TIM2_CCMR2_OC4PE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC4PE_SHIFT)) & TIM2_CCMR2_OC4PE_MASK) + +#define TIM2_CCMR2_OC4FE_SHIFT (10) +#define TIM2_CCMR2_OC4FE_MASK (0x01U << TIM2_CCMR2_OC4FE_SHIFT) +#define TIM2_CCMR2_OC4FE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC4FE_SHIFT)) & TIM2_CCMR2_OC4FE_MASK) + +#define TIM2_CCMR2_CC4S_SHIFT (8) +#define TIM2_CCMR2_CC4S_MASK (0x3U << TIM2_CCMR2_CC4S_SHIFT) +#define TIM2_CCMR2_CC4S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_CC4S_SHIFT)) & TIM2_CCMR2_CC4S_MASK) + +#define TIM2_CCMR2_OC3CE_SHIFT (7) +#define TIM2_CCMR2_OC3CE_MASK (0x01U << TIM2_CCMR2_OC3CE_SHIFT) +#define TIM2_CCMR2_OC3CE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC3CE_SHIFT)) & TIM2_CCMR2_OC3CE_MASK) + +#define TIM2_CCMR2_OC3M_SHIFT (4) +#define TIM2_CCMR2_OC3M_MASK (0x7U << TIM2_CCMR2_OC3M_SHIFT) +#define TIM2_CCMR2_OC3M(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC3M_SHIFT)) & TIM2_CCMR2_OC3M_MASK) + +#define TIM2_CCMR2_OC3PE_SHIFT (3) +#define TIM2_CCMR2_OC3PE_MASK (0x01U << TIM2_CCMR2_OC3PE_SHIFT) +#define TIM2_CCMR2_OC3PE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC3PE_SHIFT)) & TIM2_CCMR2_OC3PE_MASK) + +#define TIM2_CCMR2_OC3FE_SHIFT (2) +#define TIM2_CCMR2_OC3FE_MASK (0x01U << TIM2_CCMR2_OC3FE_SHIFT) +#define TIM2_CCMR2_OC3FE(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_OC3FE_SHIFT)) & TIM2_CCMR2_OC3FE_MASK) + +#define TIM2_CCMR2_CC3S_SHIFT (0) +#define TIM2_CCMR2_CC3S_MASK (0x3U << TIM2_CCMR2_CC3S_SHIFT) +#define TIM2_CCMR2_CC3S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_CC3S_SHIFT)) & TIM2_CCMR2_CC3S_MASK) + +/*! + * @brief TIM2_CCMR2 Register Bit Definition + */ + +#define TIM2_CCMR2_IC4F_SHIFT (12) +#define TIM2_CCMR2_IC4F_MASK (0xFU << TIM2_CCMR2_IC4F_SHIFT) +#define TIM2_CCMR2_IC4F(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_IC4F_SHIFT)) & TIM2_CCMR2_IC4F_MASK) + +#define TIM2_CCMR2_IC4PSC_SHIFT (10) +#define TIM2_CCMR2_IC4PSC_MASK (0x3U << TIM2_CCMR2_IC4PSC_SHIFT) +#define TIM2_CCMR2_IC4PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_IC4PSC_SHIFT)) & TIM2_CCMR2_IC4PSC_MASK) + +#define TIM2_CCMR2_CC4S_SHIFT (8) +#define TIM2_CCMR2_CC4S_MASK (0x3U << TIM2_CCMR2_CC4S_SHIFT) +#define TIM2_CCMR2_CC4S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_CC4S_SHIFT)) & TIM2_CCMR2_CC4S_MASK) + +#define TIM2_CCMR2_IC3F_SHIFT (4) +#define TIM2_CCMR2_IC3F_MASK (0xFU << TIM2_CCMR2_IC3F_SHIFT) +#define TIM2_CCMR2_IC3F(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_IC3F_SHIFT)) & TIM2_CCMR2_IC3F_MASK) + +#define TIM2_CCMR2_IC3PSC_SHIFT (2) +#define TIM2_CCMR2_IC3PSC_MASK (0x3U << TIM2_CCMR2_IC3PSC_SHIFT) +#define TIM2_CCMR2_IC3PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_IC3PSC_SHIFT)) & TIM2_CCMR2_IC3PSC_MASK) + +#define TIM2_CCMR2_CC3S_SHIFT (0) +#define TIM2_CCMR2_CC3S_MASK (0x3U << TIM2_CCMR2_CC3S_SHIFT) +#define TIM2_CCMR2_CC3S(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCMR2_CC3S_SHIFT)) & TIM2_CCMR2_CC3S_MASK) + +/*! + * @brief TIM2_CCER Register Bit Definition + */ + +#define TIM2_CCER_CC4NP_SHIFT (15) +#define TIM2_CCER_CC4NP_MASK (0x01U << TIM2_CCER_CC4NP_SHIFT) +#define TIM2_CCER_CC4NP(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC4NP_SHIFT)) & TIM2_CCER_CC4NP_MASK) + +#define TIM2_CCER_CC4P_SHIFT (13) +#define TIM2_CCER_CC4P_MASK (0x01U << TIM2_CCER_CC4P_SHIFT) +#define TIM2_CCER_CC4P(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC4P_SHIFT)) & TIM2_CCER_CC4P_MASK) + +#define TIM2_CCER_CC4E_SHIFT (12) +#define TIM2_CCER_CC4E_MASK (0x01U << TIM2_CCER_CC4E_SHIFT) +#define TIM2_CCER_CC4E(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC4E_SHIFT)) & TIM2_CCER_CC4E_MASK) + +#define TIM2_CCER_CC3NP_SHIFT (11) +#define TIM2_CCER_CC3NP_MASK (0x01U << TIM2_CCER_CC3NP_SHIFT) +#define TIM2_CCER_CC3NP(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC3NP_SHIFT)) & TIM2_CCER_CC3NP_MASK) + +#define TIM2_CCER_CC3P_SHIFT (9) +#define TIM2_CCER_CC3P_MASK (0x01U << TIM2_CCER_CC3P_SHIFT) +#define TIM2_CCER_CC3P(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC3P_SHIFT)) & TIM2_CCER_CC3P_MASK) + +#define TIM2_CCER_CC3E_SHIFT (8) +#define TIM2_CCER_CC3E_MASK (0x01U << TIM2_CCER_CC3E_SHIFT) +#define TIM2_CCER_CC3E(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC3E_SHIFT)) & TIM2_CCER_CC3E_MASK) + +#define TIM2_CCER_CC2NP_SHIFT (7) +#define TIM2_CCER_CC2NP_MASK (0x01U << TIM2_CCER_CC2NP_SHIFT) +#define TIM2_CCER_CC2NP(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC2NP_SHIFT)) & TIM2_CCER_CC2NP_MASK) + +#define TIM2_CCER_CC2P_SHIFT (5) +#define TIM2_CCER_CC2P_MASK (0x01U << TIM2_CCER_CC2P_SHIFT) +#define TIM2_CCER_CC2P(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC2P_SHIFT)) & TIM2_CCER_CC2P_MASK) + +#define TIM2_CCER_CC2E_SHIFT (4) +#define TIM2_CCER_CC2E_MASK (0x01U << TIM2_CCER_CC2E_SHIFT) +#define TIM2_CCER_CC2E(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC2E_SHIFT)) & TIM2_CCER_CC2E_MASK) + +#define TIM2_CCER_CC1NP_SHIFT (3) +#define TIM2_CCER_CC1NP_MASK (0x01U << TIM2_CCER_CC1NP_SHIFT) +#define TIM2_CCER_CC1NP(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC1NP_SHIFT)) & TIM2_CCER_CC1NP_MASK) + +#define TIM2_CCER_CC1P_SHIFT (1) +#define TIM2_CCER_CC1P_MASK (0x01U << TIM2_CCER_CC1P_SHIFT) +#define TIM2_CCER_CC1P(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC1P_SHIFT)) & TIM2_CCER_CC1P_MASK) + +#define TIM2_CCER_CC1E_SHIFT (0) +#define TIM2_CCER_CC1E_MASK (0x01U << TIM2_CCER_CC1E_SHIFT) +#define TIM2_CCER_CC1E(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCER_CC1E_SHIFT)) & TIM2_CCER_CC1E_MASK) + +/*! + * @brief TIM2_CNT Register Bit Definition + */ + +#define TIM2_CNT_CNT_SHIFT (0) +#define TIM2_CNT_CNT_MASK (0xFFFFFFFFU << TIM2_CNT_CNT_SHIFT) +#define TIM2_CNT_CNT(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CNT_CNT_SHIFT)) & TIM2_CNT_CNT_MASK) + +/*! + * @brief TIM2_PSC Register Bit Definition + */ + +#define TIM2_PSC_PSC_SHIFT (0) +#define TIM2_PSC_PSC_MASK (0xFFFFU << TIM2_PSC_PSC_SHIFT) +#define TIM2_PSC_PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM2_PSC_PSC_SHIFT)) & TIM2_PSC_PSC_MASK) + +/*! + * @brief TIM2_ARR Register Bit Definition + */ + +#define TIM2_ARR_ARR_SHIFT (0) +#define TIM2_ARR_ARR_MASK (0xFFFFFFFFU << TIM2_ARR_ARR_SHIFT) +#define TIM2_ARR_ARR(x) (((uint32_t)(((uint32_t)(x)) << TIM2_ARR_ARR_SHIFT)) & TIM2_ARR_ARR_MASK) + +/*! + * @brief TIM2_CCR1 Register Bit Definition + */ + +#define TIM2_CCR1_CCR1_SHIFT (0) +#define TIM2_CCR1_CCR1_MASK (0xFFFFFFFFU << TIM2_CCR1_CCR1_SHIFT) +#define TIM2_CCR1_CCR1(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCR1_CCR1_SHIFT)) & TIM2_CCR1_CCR1_MASK) + +/*! + * @brief TIM2_CCR2 Register Bit Definition + */ + +#define TIM2_CCR2_CCR2_SHIFT (0) +#define TIM2_CCR2_CCR2_MASK (0xFFFFFFFFU << TIM2_CCR2_CCR2_SHIFT) +#define TIM2_CCR2_CCR2(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCR2_CCR2_SHIFT)) & TIM2_CCR2_CCR2_MASK) + +/*! + * @brief TIM2_CCR3 Register Bit Definition + */ + +#define TIM2_CCR3_CCR3_SHIFT (0) +#define TIM2_CCR3_CCR3_MASK (0xFFFFFFFFU << TIM2_CCR3_CCR3_SHIFT) +#define TIM2_CCR3_CCR3(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCR3_CCR3_SHIFT)) & TIM2_CCR3_CCR3_MASK) + +/*! + * @brief TIM2_CCR4 Register Bit Definition + */ + +#define TIM2_CCR4_CCR4_SHIFT (0) +#define TIM2_CCR4_CCR4_MASK (0xFFFFFFFFU << TIM2_CCR4_CCR4_SHIFT) +#define TIM2_CCR4_CCR4(x) (((uint32_t)(((uint32_t)(x)) << TIM2_CCR4_CCR4_SHIFT)) & TIM2_CCR4_CCR4_MASK) + +/*! + * @brief TIM2_DCR Register Bit Definition + */ + +#define TIM2_DCR_DBL_SHIFT (8) +#define TIM2_DCR_DBL_MASK (0x1FU << TIM2_DCR_DBL_SHIFT) +#define TIM2_DCR_DBL(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DCR_DBL_SHIFT)) & TIM2_DCR_DBL_MASK) + +#define TIM2_DCR_DBA_SHIFT (0) +#define TIM2_DCR_DBA_MASK (0x1FU << TIM2_DCR_DBA_SHIFT) +#define TIM2_DCR_DBA(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DCR_DBA_SHIFT)) & TIM2_DCR_DBA_MASK) + +/*! + * @brief TIM2_DMAR Register Bit Definition + */ + +#define TIM2_DMAR_DMAB_SHIFT (0) +#define TIM2_DMAR_DMAB_MASK (0xFFFFU << TIM2_DMAR_DMAB_SHIFT) +#define TIM2_DMAR_DMAB(x) (((uint32_t)(((uint32_t)(x)) << TIM2_DMAR_DMAB_SHIFT)) & TIM2_DMAR_DMAB_MASK) + +/*! + * @brief TIM2_OR Register Bit Definition + */ + +#define TIM2_OR_TI4RMP_SHIFT (6) +#define TIM2_OR_TI4RMP_MASK (0x3U << TIM2_OR_TI4RMP_SHIFT) +#define TIM2_OR_TI4RMP(x) (((uint32_t)(((uint32_t)(x)) << TIM2_OR_TI4RMP_SHIFT)) & TIM2_OR_TI4RMP_MASK) + +#define TIM2_OR_ETRRMP_SHIFT (0) +#define TIM2_OR_ETRRMP_MASK (0x7U << TIM2_OR_ETRRMP_SHIFT) +#define TIM2_OR_ETRRMP(x) (((uint32_t)(((uint32_t)(x)) << TIM2_OR_ETRRMP_SHIFT)) & TIM2_OR_ETRRMP_MASK) + +/*! + * @} + */ /* end of group TIM2_Register_Masks */ +/****************************************************************************** + * TIM2/5 Instance +******************************************************************************/ +#define TIM2 ((TIM2_Type*)TIM2_BASE) +#define TIM5 ((TIM2_Type*)TIM5_BASE) + +/*! + * @} + */ /* end of group TIM2_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup TIM6_Peripheral_Access_Layer TIM6 Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * TIM6 Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR1; ///< Control register 1 offset: 0x00 + __IO uint32_t Reserved12[2]; ///< Reserved + __IO uint32_t DIER; ///< DMA/interrupt enable register offset: 0x0C + __IO uint32_t SR; ///< Status register offset: 0x10 + __IO uint32_t EGR; ///< Event generation register offset: 0x14 + __IO uint32_t Reserved13[3]; ///< Reserved + __IO uint32_t CNT; ///< Counter offset: 0x24 + __IO uint32_t PSC; ///< Prescaler offset: 0x28 + __IO uint32_t ARR; ///< Autoload register offset: 0x2C +} TIM6_Type; + +/******************************************************************************* + * TIM6 Type + ******************************************************************************/ + +/*! + * @addtogroup TIM6_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM6_CR1 Register Bit Definition + */ + +#define TIM6_CR1_APRE_SHIFT (7) +#define TIM6_CR1_APRE_MASK (0x01U << TIM6_CR1_APRE_SHIFT) +#define TIM6_CR1_APRE(x) (((uint32_t)(((uint32_t)(x)) << TIM6_CR1_APRE_SHIFT)) & TIM6_CR1_APRE_MASK) + +#define TIM6_CR1_OPM_SHIFT (3) +#define TIM6_CR1_OPM_MASK (0x01U << TIM6_CR1_OPM_SHIFT) +#define TIM6_CR1_OPM(x) (((uint32_t)(((uint32_t)(x)) << TIM6_CR1_OPM_SHIFT)) & TIM6_CR1_OPM_MASK) + +#define TIM6_CR1_URS_SHIFT (2) +#define TIM6_CR1_URS_MASK (0x01U << TIM6_CR1_URS_SHIFT) +#define TIM6_CR1_URS(x) (((uint32_t)(((uint32_t)(x)) << TIM6_CR1_URS_SHIFT)) & TIM6_CR1_URS_MASK) + +#define TIM6_CR1_UDIS_SHIFT (1) +#define TIM6_CR1_UDIS_MASK (0x01U << TIM6_CR1_UDIS_SHIFT) +#define TIM6_CR1_UDIS(x) (((uint32_t)(((uint32_t)(x)) << TIM6_CR1_UDIS_SHIFT)) & TIM6_CR1_UDIS_MASK) + +#define TIM6_CR1_CEN_SHIFT (0) +#define TIM6_CR1_CEN_MASK (0x01U << TIM6_CR1_CEN_SHIFT) +#define TIM6_CR1_CEN(x) (((uint32_t)(((uint32_t)(x)) << TIM6_CR1_CEN_SHIFT)) & TIM6_CR1_CEN_MASK) + +/*! + * @brief TIM6_DIER Register Bit Definition + */ + +#define TIM6_DIER_UDE_SHIFT (8) +#define TIM6_DIER_UDE_MASK (0x01U << TIM6_DIER_UDE_SHIFT) +#define TIM6_DIER_UDE(x) (((uint32_t)(((uint32_t)(x)) << TIM6_DIER_UDE_SHIFT)) & TIM6_DIER_UDE_MASK) + +#define TIM6_DIER_UIE_SHIFT (0) +#define TIM6_DIER_UIE_MASK (0x01U << TIM6_DIER_UIE_SHIFT) +#define TIM6_DIER_UIE(x) (((uint32_t)(((uint32_t)(x)) << TIM6_DIER_UIE_SHIFT)) & TIM6_DIER_UIE_MASK) + +/*! + * @brief TIM6_SR Register Bit Definition + */ + +#define TIM6_SR_UIF_SHIFT (0) +#define TIM6_SR_UIF_MASK (0x01U << TIM6_SR_UIF_SHIFT) +#define TIM6_SR_UIF(x) (((uint32_t)(((uint32_t)(x)) << TIM6_SR_UIF_SHIFT)) & TIM6_SR_UIF_MASK) + +/*! + * @brief TIM6_EGR Register Bit Definition + */ + +#define TIM6_EGR_UG_SHIFT (0) +#define TIM6_EGR_UG_MASK (0x01U << TIM6_EGR_UG_SHIFT) +#define TIM6_EGR_UG(x) (((uint32_t)(((uint32_t)(x)) << TIM6_EGR_UG_SHIFT)) & TIM6_EGR_UG_MASK) + +/*! + * @brief TIM6_CNT Register Bit Definition + */ + +#define TIM6_CNT_CNT_SHIFT (0) +#define TIM6_CNT_CNT_MASK (0xFFFFU << TIM6_CNT_CNT_SHIFT) +#define TIM6_CNT_CNT(x) (((uint32_t)(((uint32_t)(x)) << TIM6_CNT_CNT_SHIFT)) & TIM6_CNT_CNT_MASK) + +/*! + * @brief TIM6_PSC Register Bit Definition + */ + +#define TIM6_PSC_PSC_SHIFT (0) +#define TIM6_PSC_PSC_MASK (0xFFFFU << TIM6_PSC_PSC_SHIFT) +#define TIM6_PSC_PSC(x) (((uint32_t)(((uint32_t)(x)) << TIM6_PSC_PSC_SHIFT)) & TIM6_PSC_PSC_MASK) + +/*! + * @brief TIM6_ARR Register Bit Definition + */ + +#define TIM6_ARR_ARR_SHIFT (0) +#define TIM6_ARR_ARR_MASK (0xFFFFU << TIM6_ARR_ARR_SHIFT) +#define TIM6_ARR_ARR(x) (((uint32_t)(((uint32_t)(x)) << TIM6_ARR_ARR_SHIFT)) & TIM6_ARR_ARR_MASK) + +/*! + * @} + */ /* end of group TIM6_Register_Masks */ +/****************************************************************************** + * TIM6/7 Instance +******************************************************************************/ +#define TIM6 ((TIM6_Type*)TIM6_BASE) +#define TIM7 ((TIM6_Type*)TIM7_BASE) + +/*! + * @} + */ /* end of group TIM6_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup IWDG_Peripheral_Access_Layer IWDG Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * IWDG Type + ******************************************************************************/ +typedef struct { + __IO uint32_t KR; ///< Key register offset: 0x00 + __IO uint32_t PR; ///< Prescaler register offset: 0x04 + __IO uint32_t RLR; ///< Reload register offset: 0x08 + __IO uint32_t SR; ///< Status register offset: 0x0C + __IO uint32_t CR; ///< Control register offset: 0x10 + __IO uint32_t IGEN; ///< Interrupt generation register offset: 0x14 + __IO uint32_t CNT; ///< Counting register offset: 0x18 + __IO uint32_t PS; ///< Divide count register offset: 0x1c +} IWDG_Type; + +/******************************************************************************* + * IWDG Type + ******************************************************************************/ + +/*! + * @addtogroup IWDG_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief IWDG_KR Register Bit Definition + */ + +#define IWDG_KR_KEY_SHIFT (0) +#define IWDG_KR_KEY_MASK (0xFFFFU << IWDG_KR_KEY_SHIFT) +#define IWDG_KR_KEY(x) (((uint32_t)(((uint32_t)(x)) << IWDG_KR_KEY_SHIFT)) & IWDG_KR_KEY_MASK) + +/*! + * @brief IWDG_PR Register Bit Definition + */ + +#define IWDG_PR_PR_SHIFT (0) +#define IWDG_PR_PR_MASK (0x7U << IWDG_PR_PR_SHIFT) +#define IWDG_PR_PR(x) (((uint32_t)(((uint32_t)(x)) << IWDG_PR_PR_SHIFT)) & IWDG_PR_PR_MASK) + +/*! + * @brief IWDG_RLR Register Bit Definition + */ + +#define IWDG_RLR_RL_SHIFT (0) +#define IWDG_RLR_RL_MASK (0xFFFU << IWDG_RLR_RL_SHIFT) +#define IWDG_RLR_RL(x) (((uint32_t)(((uint32_t)(x)) << IWDG_RLR_RL_SHIFT)) & IWDG_RLR_RL_MASK) + +/*! + * @brief IWDG_SR Register Bit Definition + */ + +#define IWDG_SR_UPDATE_SHIFT (3) +#define IWDG_SR_UPDATE_MASK (0x01U << IWDG_SR_UPDATE_SHIFT) +#define IWDG_SR_UPDATE(x) (((uint32_t)(((uint32_t)(x)) << IWDG_SR_UPDATE_SHIFT)) & IWDG_SR_UPDATE_MASK) + +#define IWDG_SR_IVU_SHIFT (2) +#define IWDG_SR_IVU_MASK (0x01U << IWDG_SR_IVU_SHIFT) +#define IWDG_SR_IVU(x) (((uint32_t)(((uint32_t)(x)) << IWDG_SR_IVU_SHIFT)) & IWDG_SR_IVU_MASK) + +#define IWDG_SR_RVU_SHIFT (1) +#define IWDG_SR_RVU_MASK (0x01U << IWDG_SR_RVU_SHIFT) +#define IWDG_SR_RVU(x) (((uint32_t)(((uint32_t)(x)) << IWDG_SR_RVU_SHIFT)) & IWDG_SR_RVU_MASK) + +#define IWDG_SR_PVU_SHIFT (0) +#define IWDG_SR_PVU_MASK (0x01U << IWDG_SR_PVU_SHIFT) +#define IWDG_SR_PVU(x) (((uint32_t)(((uint32_t)(x)) << IWDG_SR_PVU_SHIFT)) & IWDG_SR_PVU_MASK) + +/*! + * @brief IWDG_CR Register Bit Definition + */ + +#define IWDG_CR_IRQCLR_SHIFT (1) +#define IWDG_CR_IRQCLR_MASK (0x01U << IWDG_CR_IRQCLR_SHIFT) +#define IWDG_CR_IRQCLR(x) (((uint32_t)(((uint32_t)(x)) << IWDG_CR_IRQCLR_SHIFT)) & IWDG_CR_IRQCLR_MASK) + +#define IWDG_CR_IRQSEL_SHIFT (0) +#define IWDG_CR_IRQSEL_MASK (0x01U << IWDG_CR_IRQSEL_SHIFT) +#define IWDG_CR_IRQSEL(x) (((uint32_t)(((uint32_t)(x)) << IWDG_CR_IRQSEL_SHIFT)) & IWDG_CR_IRQSEL_MASK) + +/*! + * @brief IWDG_IGEN Register Bit Definition + */ + +#define IWDG_IGEN_IGEN_SHIFT (0) +#define IWDG_IGEN_IGEN_MASK (0xFFFU << IWDG_IGEN_IGEN_SHIFT) +#define IWDG_IGEN_IGEN(x) (((uint32_t)(((uint32_t)(x)) << IWDG_IGEN_IGEN_SHIFT)) & IWDG_IGEN_IGEN_MASK) + +/*! + * @brief IWDG_CNT Register Bit Definition + */ + +#define IWDG_CNT_IWDGCNT_SHIFT (0) +#define IWDG_CNT_IWDGCNT_MASK (0xFFFU << IWDG_CNT_IWDGCNT_SHIFT) +#define IWDG_CNT_IWDGCNT(x) (((uint32_t)(((uint32_t)(x)) << IWDG_CNT_IWDGCNT_SHIFT)) & IWDG_CNT_IWDGCNT_MASK) + +/*! + * @brief IWDG_PS Register Bit Definition + */ + +#define IWDG_PS_IWDGPS_SHIFT (0) +#define IWDG_PS_IWDGPS_MASK (0xFFU << IWDG_PS_IWDGPS_SHIFT) +#define IWDG_PS_IWDGPS(x) (((uint32_t)(((uint32_t)(x)) << IWDG_PS_IWDGPS_SHIFT)) & IWDG_PS_IWDGPS_MASK) + +/*! + * @} + */ /* end of group IWDG_Register_Masks */ +/****************************************************************************** + * IWDG Instance +******************************************************************************/ +#define IWDG ((IWDG_Type*)IWDG_BASE) + +/*! + * @} + */ /* end of group IWDG_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup WWDG_Peripheral_Access_Layer WWDG Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * WWDG Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR; ///< Control register offset: 0x00 + __IO uint32_t CFGR; ///< Configuration register offset: 0x04 + __IO uint32_t SR; ///< Status register offset: 0x08 +} WWDG_Type; + +/******************************************************************************* + * WWDG Type + ******************************************************************************/ + +/*! + * @addtogroup WWDG_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief WWDG_CR Register Bit Definition + */ + +#define WWDG_CR_WDGA_SHIFT (7) +#define WWDG_CR_WDGA_MASK (0x01U << WWDG_CR_WDGA_SHIFT) +#define WWDG_CR_WDGA(x) (((uint32_t)(((uint32_t)(x)) << WWDG_CR_WDGA_SHIFT)) & WWDG_CR_WDGA_MASK) + +#define WWDG_CR_T_SHIFT (0) +#define WWDG_CR_T_MASK (0x7FU << WWDG_CR_T_SHIFT) +#define WWDG_CR_T(x) (((uint32_t)(((uint32_t)(x)) << WWDG_CR_T_SHIFT)) & WWDG_CR_T_MASK) + +/*! + * @brief WWDG_CFGR Register Bit Definition + */ + +#define WWDG_CFGR_EWI_SHIFT (9) +#define WWDG_CFGR_EWI_MASK (0x01U << WWDG_CFGR_EWI_SHIFT) +#define WWDG_CFGR_EWI(x) (((uint32_t)(((uint32_t)(x)) << WWDG_CFGR_EWI_SHIFT)) & WWDG_CFGR_EWI_MASK) + +#define WWDG_CFGR_WDGTB_SHIFT (7) +#define WWDG_CFGR_WDGTB_MASK (0x3U << WWDG_CFGR_WDGTB_SHIFT) +#define WWDG_CFGR_WDGTB(x) (((uint32_t)(((uint32_t)(x)) << WWDG_CFGR_WDGTB_SHIFT)) & WWDG_CFGR_WDGTB_MASK) + +#define WWDG_CFGR_W_SHIFT (0) +#define WWDG_CFGR_W_MASK (0x7FU << WWDG_CFGR_W_SHIFT) +#define WWDG_CFGR_W(x) (((uint32_t)(((uint32_t)(x)) << WWDG_CFGR_W_SHIFT)) & WWDG_CFGR_W_MASK) + +/*! + * @brief WWDG_SR Register Bit Definition + */ + +#define WWDG_SR_EWIF_SHIFT (0) +#define WWDG_SR_EWIF_MASK (0x01U << WWDG_SR_EWIF_SHIFT) +#define WWDG_SR_EWIF(x) (((uint32_t)(((uint32_t)(x)) << WWDG_SR_EWIF_SHIFT)) & WWDG_SR_EWIF_MASK) + +/*! + * @} + */ /* end of group WWDG_Register_Masks */ +/****************************************************************************** + * WWDG Instance +******************************************************************************/ +#define WWDG ((WWDG_Type*)WWDG_BASE) + +/*! + * @} + */ /* end of group WWDG_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup RTC_Peripheral_Access_Layer RTC Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * RTC Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CRH; ///< RTC control register high offset: 0x00 + __IO uint32_t CRL; ///< RTC control register low bit offset: 0x04 + __IO uint32_t PRLH; ///< RTC prescaler load register high offset: 0x08 + __IO uint32_t PRLL; ///< RTC prescaler load register low bit offset: 0x0C + __IO uint32_t DIVH; ///< RTC prescaler frequency division factor register high bitoffset: 0x10 + __IO uint32_t DIVL; ///< RTC prescaler division factor register low bitoffset: 0x14 + __IO uint32_t CNTH; ///< RTC counter register high bit offset: 0x18 + __IO uint32_t CNTL; ///< RTC counter register low bit offset: 0x1C + __IO uint32_t ALRH; ///< RTC alarm register high bit offset: 0x20 + __IO uint32_t ALRL; ///< RTC alarm register low bit offset: 0x24 + __IO uint32_t MSRH; ///< RTC millisecond register high offset: 0x28 + __IO uint32_t MSRL; ///< RTC millisecond register low bit offset: 0x2C + __IO uint32_t Reserved14[3]; ///< Reserved + __IO uint32_t LSECFG; ///< RTC configuration register offset: 0x3C +} RTC_Type; +/******************************************************************************* + * RTC Type + ******************************************************************************/ + +/*! + * @addtogroup RTC_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief RTC_CRH Register Bit Definition + */ + +#define RTC_CRH_OWIE_SHIFT (2) +#define RTC_CRH_OWIE_MASK (0x01U << RTC_CRH_OWIE_SHIFT) +#define RTC_CRH_OWIE(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRH_OWIE_SHIFT)) & RTC_CRH_OWIE_MASK) + +#define RTC_CRH_ALRIE_SHIFT (1) +#define RTC_CRH_ALRIE_MASK (0x01U << RTC_CRH_ALRIE_SHIFT) +#define RTC_CRH_ALRIE(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRH_ALRIE_SHIFT)) & RTC_CRH_ALRIE_MASK) + +#define RTC_CRH_SECIE_SHIFT (0) +#define RTC_CRH_SECIE_MASK (0x01U << RTC_CRH_SECIE_SHIFT) +#define RTC_CRH_SECIE(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRH_SECIE_SHIFT)) & RTC_CRH_SECIE_MASK) + +/*! + * @brief RTC_CRL Register Bit Definition + */ + +#define RTC_CRL_ALPEN_SHIFT (6) +#define RTC_CRL_ALPEN_MASK (0x01U << RTC_CRL_ALPEN_SHIFT) +#define RTC_CRL_ALPEN(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRL_ALPEN_SHIFT)) & RTC_CRL_ALPEN_MASK) + +#define RTC_CRL_RTOFF_SHIFT (5) +#define RTC_CRL_RTOFF_MASK (0x01U << RTC_CRL_RTOFF_SHIFT) +#define RTC_CRL_RTOFF(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRL_RTOFF_SHIFT)) & RTC_CRL_RTOFF_MASK) + +#define RTC_CRL_CNF_SHIFT (4) +#define RTC_CRL_CNF_MASK (0x01U << RTC_CRL_CNF_SHIFT) +#define RTC_CRL_CNF(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRL_CNF_SHIFT)) & RTC_CRL_CNF_MASK) + +#define RTC_CRL_RSF_SHIFT (3) +#define RTC_CRL_RSF_MASK (0x01U << RTC_CRL_RSF_SHIFT) +#define RTC_CRL_RSF(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRL_RSF_SHIFT)) & RTC_CRL_RSF_MASK) + +#define RTC_CRL_OWF_SHIFT (2) +#define RTC_CRL_OWF_MASK (0x01U << RTC_CRL_OWF_SHIFT) +#define RTC_CRL_OWF(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRL_OWF_SHIFT)) & RTC_CRL_OWF_MASK) + +#define RTC_CRL_ALRF_SHIFT (1) +#define RTC_CRL_ALRF_MASK (0x01U << RTC_CRL_ALRF_SHIFT) +#define RTC_CRL_ALRF(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRL_ALRF_SHIFT)) & RTC_CRL_ALRF_MASK) + +#define RTC_CRL_SECF_SHIFT (0) +#define RTC_CRL_SECF_MASK (0x01U << RTC_CRL_SECF_SHIFT) +#define RTC_CRL_SECF(x) (((uint32_t)(((uint32_t)(x)) << RTC_CRL_SECF_SHIFT)) & RTC_CRL_SECF_MASK) + +/*! + * @brief RTC_PRLH Register Bit Definition + */ + +#define RTC_PRLH_PRL_SHIFT (0) +#define RTC_PRLH_PRL_MASK (0xFU << RTC_PRLH_PRL_SHIFT) +#define RTC_PRLH_PRL(x) (((uint32_t)(((uint32_t)(x)) << RTC_PRLH_PRL_SHIFT)) & RTC_PRLH_PRL_MASK) + +/*! + * @brief RTC_PRLL Register Bit Definition + */ + +#define RTC_PRLL_PRL_SHIFT (0) +#define RTC_PRLL_PRL_MASK (0xFFFFU << RTC_PRLL_PRL_SHIFT) +#define RTC_PRLL_PRL(x) (((uint32_t)(((uint32_t)(x)) << RTC_PRLL_PRL_SHIFT)) & RTC_PRLL_PRL_MASK) + +/*! + * @brief RTC_DIVH Register Bit Definition + */ + +#define RTC_DIVH_DIV_SHIFT (0) +#define RTC_DIVH_DIV_MASK (0xFU << RTC_DIVH_DIV_SHIFT) +#define RTC_DIVH_DIV(x) (((uint32_t)(((uint32_t)(x)) << RTC_DIVH_DIV_SHIFT)) & RTC_DIVH_DIV_MASK) + +/*! + * @brief RTC_DIVL Register Bit Definition + */ + +#define RTC_DIVL_DIV_SHIFT (0) +#define RTC_DIVL_DIV_MASK (0xFFFFU << RTC_DIVL_DIV_SHIFT) +#define RTC_DIVL_DIV(x) (((uint32_t)(((uint32_t)(x)) << RTC_DIVL_DIV_SHIFT)) & RTC_DIVL_DIV_MASK) + +/*! + * @brief RTC_CNTH Register Bit Definition + */ + +#define RTC_CNTH_CNT_SHIFT (0) +#define RTC_CNTH_CNT_MASK (0xFFFFU << RTC_CNTH_CNT_SHIFT) +#define RTC_CNTH_CNT(x) (((uint32_t)(((uint32_t)(x)) << RTC_CNTH_CNT_SHIFT)) & RTC_CNTH_CNT_MASK) + +/*! + * @brief RTC_CNTL Register Bit Definition + */ + +#define RTC_CNTL_CNT_SHIFT (0) +#define RTC_CNTL_CNT_MASK (0xFFFFU << RTC_CNTL_CNT_SHIFT) +#define RTC_CNTL_CNT(x) (((uint32_t)(((uint32_t)(x)) << RTC_CNTL_CNT_SHIFT)) & RTC_CNTL_CNT_MASK) + +/*! + * @brief RTC_ALRH Register Bit Definition + */ + +#define RTC_ALRH_ALR_SHIFT (0) +#define RTC_ALRH_ALR_MASK (0xFFFFU << RTC_ALRH_ALR_SHIFT) +#define RTC_ALRH_ALR(x) (((uint32_t)(((uint32_t)(x)) << RTC_ALRH_ALR_SHIFT)) & RTC_ALRH_ALR_MASK) + +/*! + * @brief RTC_ALRL Register Bit Definition + */ + +#define RTC_ALRL_ALR_SHIFT (0) +#define RTC_ALRL_ALR_MASK (0xFFFFU << RTC_ALRL_ALR_SHIFT) +#define RTC_ALRL_ALR(x) (((uint32_t)(((uint32_t)(x)) << RTC_ALRL_ALR_SHIFT)) & RTC_ALRL_ALR_MASK) + +/*! + * @brief RTC_MSRH Register Bit Definition + */ + +#define RTC_MSRH_MSR_SHIFT (0) +#define RTC_MSRH_MSR_MASK (0xFU << RTC_MSRH_MSR_SHIFT) +#define RTC_MSRH_MSR(x) (((uint32_t)(((uint32_t)(x)) << RTC_MSRH_MSR_SHIFT)) & RTC_MSRH_MSR_MASK) + +/*! + * @brief RTC_MSRL Register Bit Definition + */ + +#define RTC_MSRL_MSR_SHIFT (0) +#define RTC_MSRL_MSR_MASK (0xFFFFU << RTC_MSRL_MSR_SHIFT) +#define RTC_MSRL_MSR(x) (((uint32_t)(((uint32_t)(x)) << RTC_MSRL_MSR_SHIFT)) & RTC_MSRL_MSR_MASK) + +/*! + * @brief RTC_LSECFG Register Bit Definition + */ + +#define RTC_LSECFG_LSEIB_SHIFT (8) +#define RTC_LSECFG_LSEIB_MASK (0x3U << RTC_LSECFG_LSEIB_SHIFT) +#define RTC_LSECFG_LSEIB(x) (((uint32_t)(((uint32_t)(x)) << RTC_LSECFG_LSEIB_SHIFT)) & RTC_LSECFG_LSEIB_MASK) + +#define RTC_LSECFG_LSERFBSEL_SHIFT (6) +#define RTC_LSECFG_LSERFBSEL_MASK (0x3U << RTC_LSECFG_LSERFBSEL_SHIFT) +#define RTC_LSECFG_LSERFBSEL(x) (((uint32_t)(((uint32_t)(x)) << RTC_LSECFG_LSERFBSEL_SHIFT)) & RTC_LSECFG_LSERFBSEL_MASK) + +#define RTC_LSECFG_LSEDR_SHIFT (4) +#define RTC_LSECFG_LSEDR_MASK (0x3U << RTC_LSECFG_LSEDR_SHIFT) +#define RTC_LSECFG_LSEDR(x) (((uint32_t)(((uint32_t)(x)) << RTC_LSECFG_LSEDR_SHIFT)) & RTC_LSECFG_LSEDR_MASK) + +#define RTC_LSECFG_LSETEST_SHIFT (0) +#define RTC_LSECFG_LSETEST_MASK (0xFU << RTC_LSECFG_LSETEST_SHIFT) +#define RTC_LSECFG_LSETEST(x) (((uint32_t)(((uint32_t)(x)) << RTC_LSECFG_LSETEST_SHIFT)) & RTC_LSECFG_LSETEST_MASK) + +/*! + * @} + */ /* end of group RTC_Register_Masks */ +/****************************************************************************** + * RTC Instance +******************************************************************************/ +#define RTC ((RTC_Type*)RTC_BKP_BASE) + +/*! + * @} + */ /* end of group RTC_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup UART_Peripheral_Access_Layer UART Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * UART Type + ******************************************************************************/ +typedef struct { + __IO uint32_t TDR; ///< UART transmit data register offset: 0x00 + __IO uint32_t RDR; ///< UART receive data register offset: 0x04 + __IO uint32_t CSR; ///< UART current status register offset: 0x08 + __IO uint32_t ISR; ///< UART interrupt status register offset: 0x0C + __IO uint32_t IER; ///< UART interrupt enable register offset: 0x10 + __IO uint32_t ICR; ///< UART interrupt clear register offset: 0x14 + __IO uint32_t GCR; ///< UART global control register offset: 0x18 + __IO uint32_t CCR; ///< UART general control register offset: 0x1C + __IO uint32_t BRR; ///< UART baud rate register offset: 0x20 + __IO uint32_t FRA; ///< UART Fractional Baud Rate Register offset: 0x24 + __IO uint32_t RXADDR; ///< UART receive address register offset: 0x28 + __IO uint32_t RXMASK; ///< UART receive mask register offset: 0x2C + __IO uint32_t SCR; ///< UART SCR register offset: 0x30 + __IO uint32_t IDLR; ///< UART IDLE data length register offset: 0x34 + __IO uint32_t ABRCR; ///< UART ABRCR automatic baud rate control registeroffset: 0x38 + __IO uint32_t IRDA; ///< UART IRDA infrared function control register offset: 0x3C +} UART_Type; + +/******************************************************************************* + * UART Type + ******************************************************************************/ + +/*! + * @addtogroup UART_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief UART_TDR Register Bit Definition + */ + +#define UART_TDR_TXREG_SHIFT (0) +#define UART_TDR_TXREG_MASK (0x1FFU << UART_TDR_TXREG_SHIFT) +#define UART_TDR_TXREG(x) (((uint32_t)(((uint32_t)(x)) << UART_TDR_TXREG_SHIFT)) & UART_TDR_TXREG_MASK) + +/*! + * @brief UART_RDR Register Bit Definition + */ + +#define UART_RDR_RXREG_SHIFT (0) +#define UART_RDR_RXREG_MASK (0x1FFU << UART_RDR_RXREG_SHIFT) +#define UART_RDR_RXREG(x) (((uint32_t)(((uint32_t)(x)) << UART_RDR_RXREG_SHIFT)) & UART_RDR_RXREG_MASK) + +/*! + * @brief UART_CSR Register Bit Definition + */ + +#define UART_CSR_TXEPT_SHIFT (3) +#define UART_CSR_TXEPT_MASK (0x01U << UART_CSR_TXEPT_SHIFT) +#define UART_CSR_TXEPT(x) (((uint32_t)(((uint32_t)(x)) << UART_CSR_TXEPT_SHIFT)) & UART_CSR_TXEPT_MASK) + +#define UART_CSR_TXFULL_SHIFT (2) +#define UART_CSR_TXFULL_MASK (0x01U << UART_CSR_TXFULL_SHIFT) +#define UART_CSR_TXFULL(x) (((uint32_t)(((uint32_t)(x)) << UART_CSR_TXFULL_SHIFT)) & UART_CSR_TXFULL_MASK) + +#define UART_CSR_RXAVL_SHIFT (1) +#define UART_CSR_RXAVL_MASK (0x01U << UART_CSR_RXAVL_SHIFT) +#define UART_CSR_RXAVL(x) (((uint32_t)(((uint32_t)(x)) << UART_CSR_RXAVL_SHIFT)) & UART_CSR_RXAVL_MASK) + +#define UART_CSR_TXC_SHIFT (0) +#define UART_CSR_TXC_MASK (0x01U << UART_CSR_TXC_SHIFT) +#define UART_CSR_TXC(x) (((uint32_t)(((uint32_t)(x)) << UART_CSR_TXC_SHIFT)) & UART_CSR_TXC_MASK) + +/*! + * @brief UART_ISR Register Bit Definition + */ + +#define UART_ISR_ABRERRINTF_SHIFT (11) +#define UART_ISR_ABRERRINTF_MASK (0x01U << UART_ISR_ABRERRINTF_SHIFT) +#define UART_ISR_ABRERRINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_ABRERRINTF_SHIFT)) & UART_ISR_ABRERRINTF_MASK) + +#define UART_ISR_ABRENDINTF_SHIFT (10) +#define UART_ISR_ABRENDINTF_MASK (0x01U << UART_ISR_ABRENDINTF_SHIFT) +#define UART_ISR_ABRENDINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_ABRENDINTF_SHIFT)) & UART_ISR_ABRENDINTF_MASK) + +#define UART_ISR_RXIDLEINTF_SHIFT (9) +#define UART_ISR_RXIDLEINTF_MASK (0x01U << UART_ISR_RXIDLEINTF_SHIFT) +#define UART_ISR_RXIDLEINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_RXIDLEINTF_SHIFT)) & UART_ISR_RXIDLEINTF_MASK) + +#define UART_ISR_RXB8INTF_SHIFT (8) +#define UART_ISR_RXB8INTF_MASK (0x01U << UART_ISR_RXB8INTF_SHIFT) +#define UART_ISR_RXB8INTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_RXB8INTF_SHIFT)) & UART_ISR_RXB8INTF_MASK) + +#define UART_ISR_TXBRKINTF_SHIFT (7) +#define UART_ISR_TXBRKINTF_MASK (0x01U << UART_ISR_TXBRKINTF_SHIFT) +#define UART_ISR_TXBRKINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_TXBRKINTF_SHIFT)) & UART_ISR_TXBRKINTF_MASK) + +#define UART_ISR_RXBRKINTF_SHIFT (6) +#define UART_ISR_RXBRKINTF_MASK (0x01U << UART_ISR_RXBRKINTF_SHIFT) +#define UART_ISR_RXBRKINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_RXBRKINTF_SHIFT)) & UART_ISR_RXBRKINTF_MASK) + +#define UART_ISR_RXFERRINTF_SHIFT (5) +#define UART_ISR_RXFERRINTF_MASK (0x01U << UART_ISR_RXFERRINTF_SHIFT) +#define UART_ISR_RXFERRINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_RXFERRINTF_SHIFT)) & UART_ISR_RXFERRINTF_MASK) + +#define UART_ISR_RXPERRINTF_SHIFT (4) +#define UART_ISR_RXPERRINTF_MASK (0x01U << UART_ISR_RXPERRINTF_SHIFT) +#define UART_ISR_RXPERRINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_RXPERRINTF_SHIFT)) & UART_ISR_RXPERRINTF_MASK) + +#define UART_ISR_RXOERRINTF_SHIFT (3) +#define UART_ISR_RXOERRINTF_MASK (0x01U << UART_ISR_RXOERRINTF_SHIFT) +#define UART_ISR_RXOERRINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_RXOERRINTF_SHIFT)) & UART_ISR_RXOERRINTF_MASK) + +#define UART_ISR_TXCINTF_SHIFT (2) +#define UART_ISR_TXCINTF_MASK (0x01U << UART_ISR_TXCINTF_SHIFT) +#define UART_ISR_TXCINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_TXCINTF_SHIFT)) & UART_ISR_TXCINTF_MASK) + +#define UART_ISR_RXINTF_SHIFT (1) +#define UART_ISR_RXINTF_MASK (0x01U << UART_ISR_RXINTF_SHIFT) +#define UART_ISR_RXINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_RXINTF_SHIFT)) & UART_ISR_RXINTF_MASK) + +#define UART_ISR_TXINTF_SHIFT (0) +#define UART_ISR_TXINTF_MASK (0x01U << UART_ISR_TXINTF_SHIFT) +#define UART_ISR_TXINTF(x) (((uint32_t)(((uint32_t)(x)) << UART_ISR_TXINTF_SHIFT)) & UART_ISR_TXINTF_MASK) + +/*! + * @brief UART_IER Register Bit Definition + */ + +#define UART_IER_ABRERRIEN_SHIFT (11) +#define UART_IER_ABRERRIEN_MASK (0x01U << UART_IER_ABRERRIEN_SHIFT) +#define UART_IER_ABRERRIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_ABRERRIEN_SHIFT)) & UART_IER_ABRERRIEN_MASK) + +#define UART_IER_ABRENDIEN_SHIFT (10) +#define UART_IER_ABRENDIEN_MASK (0x01U << UART_IER_ABRENDIEN_SHIFT) +#define UART_IER_ABRENDIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_ABRENDIEN_SHIFT)) & UART_IER_ABRENDIEN_MASK) + +#define UART_IER_RXIDLEIEN_SHIFT (9) +#define UART_IER_RXIDLEIEN_MASK (0x01U << UART_IER_RXIDLEIEN_SHIFT) +#define UART_IER_RXIDLEIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_RXIDLEIEN_SHIFT)) & UART_IER_RXIDLEIEN_MASK) + +#define UART_IER_RXB8IEN_SHIFT (8) +#define UART_IER_RXB8IEN_MASK (0x01U << UART_IER_RXB8IEN_SHIFT) +#define UART_IER_RXB8IEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_RXB8IEN_SHIFT)) & UART_IER_RXB8IEN_MASK) + +#define UART_IER_TXBRKIEN_SHIFT (7) +#define UART_IER_TXBRKIEN_MASK (0x01U << UART_IER_TXBRKIEN_SHIFT) +#define UART_IER_TXBRKIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_TXBRKIEN_SHIFT)) & UART_IER_TXBRKIEN_MASK) + +#define UART_IER_RXBRKIEN_SHIFT (6) +#define UART_IER_RXBRKIEN_MASK (0x01U << UART_IER_RXBRKIEN_SHIFT) +#define UART_IER_RXBRKIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_RXBRKIEN_SHIFT)) & UART_IER_RXBRKIEN_MASK) + +#define UART_IER_RXFERRIEN_SHIFT (5) +#define UART_IER_RXFERRIEN_MASK (0x01U << UART_IER_RXFERRIEN_SHIFT) +#define UART_IER_RXFERRIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_RXFERRIEN_SHIFT)) & UART_IER_RXFERRIEN_MASK) + +#define UART_IER_RXPERRIEN_SHIFT (4) +#define UART_IER_RXPERRIEN_MASK (0x01U << UART_IER_RXPERRIEN_SHIFT) +#define UART_IER_RXPERRIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_RXPERRIEN_SHIFT)) & UART_IER_RXPERRIEN_MASK) + +#define UART_IER_RXOERRIEN_SHIFT (3) +#define UART_IER_RXOERRIEN_MASK (0x01U << UART_IER_RXOERRIEN_SHIFT) +#define UART_IER_RXOERRIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_RXOERRIEN_SHIFT)) & UART_IER_RXOERRIEN_MASK) + +#define UART_IER_TXCIEN_SHIFT (2) +#define UART_IER_TXCIEN_MASK (0x01U << UART_IER_TXCIEN_SHIFT) +#define UART_IER_TXCIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_TXCIEN_SHIFT)) & UART_IER_TXCIEN_MASK) + +#define UART_IER_RXIEN_SHIFT (1) +#define UART_IER_RXIEN_MASK (0x01U << UART_IER_RXIEN_SHIFT) +#define UART_IER_RXIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_RXIEN_SHIFT)) & UART_IER_RXIEN_MASK) + +#define UART_IER_TXIEN_SHIFT (0) +#define UART_IER_TXIEN_MASK (0x01U << UART_IER_TXIEN_SHIFT) +#define UART_IER_TXIEN(x) (((uint32_t)(((uint32_t)(x)) << UART_IER_TXIEN_SHIFT)) & UART_IER_TXIEN_MASK) + +/*! + * @brief UART_ICR Register Bit Definition + */ + +#define UART_ICR_ABRERRICLR_SHIFT (11) +#define UART_ICR_ABRERRICLR_MASK (0x01U << UART_ICR_ABRERRICLR_SHIFT) +#define UART_ICR_ABRERRICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_ABRERRICLR_SHIFT)) & UART_ICR_ABRERRICLR_MASK) + +#define UART_ICR_ABRENDICLR_SHIFT (10) +#define UART_ICR_ABRENDICLR_MASK (0x01U << UART_ICR_ABRENDICLR_SHIFT) +#define UART_ICR_ABRENDICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_ABRENDICLR_SHIFT)) & UART_ICR_ABRENDICLR_MASK) + +#define UART_ICR_RXIDLEICLR_SHIFT (9) +#define UART_ICR_RXIDLEICLR_MASK (0x01U << UART_ICR_RXIDLEICLR_SHIFT) +#define UART_ICR_RXIDLEICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_RXIDLEICLR_SHIFT)) & UART_ICR_RXIDLEICLR_MASK) + +#define UART_ICR_RXB8ICLR_SHIFT (8) +#define UART_ICR_RXB8ICLR_MASK (0x01U << UART_ICR_RXB8ICLR_SHIFT) +#define UART_ICR_RXB8ICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_RXB8ICLR_SHIFT)) & UART_ICR_RXB8ICLR_MASK) + +#define UART_ICR_TXBRKICLR_SHIFT (7) +#define UART_ICR_TXBRKICLR_MASK (0x01U << UART_ICR_TXBRKICLR_SHIFT) +#define UART_ICR_TXBRKICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_TXBRKICLR_SHIFT)) & UART_ICR_TXBRKICLR_MASK) + +#define UART_ICR_RXBRKICLR_SHIFT (6) +#define UART_ICR_RXBRKICLR_MASK (0x01U << UART_ICR_RXBRKICLR_SHIFT) +#define UART_ICR_RXBRKICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_RXBRKICLR_SHIFT)) & UART_ICR_RXBRKICLR_MASK) + +#define UART_ICR_RXFERRICLR_SHIFT (5) +#define UART_ICR_RXFERRICLR_MASK (0x01U << UART_ICR_RXFERRICLR_SHIFT) +#define UART_ICR_RXFERRICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_RXFERRICLR_SHIFT)) & UART_ICR_RXFERRICLR_MASK) + +#define UART_ICR_RXPERRICLR_SHIFT (4) +#define UART_ICR_RXPERRICLR_MASK (0x01U << UART_ICR_RXPERRICLR_SHIFT) +#define UART_ICR_RXPERRICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_RXPERRICLR_SHIFT)) & UART_ICR_RXPERRICLR_MASK) + +#define UART_ICR_RXOERRICLR_SHIFT (3) +#define UART_ICR_RXOERRICLR_MASK (0x01U << UART_ICR_RXOERRICLR_SHIFT) +#define UART_ICR_RXOERRICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_RXOERRICLR_SHIFT)) & UART_ICR_RXOERRICLR_MASK) + +#define UART_ICR_TXCICLR_SHIFT (2) +#define UART_ICR_TXCICLR_MASK (0x01U << UART_ICR_TXCICLR_SHIFT) +#define UART_ICR_TXCICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_TXCICLR_SHIFT)) & UART_ICR_TXCICLR_MASK) + +#define UART_ICR_RXICLR_SHIFT (1) +#define UART_ICR_RXICLR_MASK (0x01U << UART_ICR_RXICLR_SHIFT) +#define UART_ICR_RXICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_RXICLR_SHIFT)) & UART_ICR_RXICLR_MASK) + +#define UART_ICR_TXICLR_SHIFT (0) +#define UART_ICR_TXICLR_MASK (0x01U << UART_ICR_TXICLR_SHIFT) +#define UART_ICR_TXICLR(x) (((uint32_t)(((uint32_t)(x)) << UART_ICR_TXICLR_SHIFT)) & UART_ICR_TXICLR_MASK) + +/*! + * @brief UART_GCR Register Bit Definition + */ + +#define UART_GCR_TXTOG_SHIFT (10) +#define UART_GCR_TXTOG_MASK (0x01U << UART_GCR_TXTOG_SHIFT) +#define UART_GCR_TXTOG(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_TXTOG_SHIFT)) & UART_GCR_TXTOG_MASK) + +#define UART_GCR_RXTOG_SHIFT (9) +#define UART_GCR_RXTOG_MASK (0x01U << UART_GCR_RXTOG_SHIFT) +#define UART_GCR_RXTOG(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_RXTOG_SHIFT)) & UART_GCR_RXTOG_MASK) + +#define UART_GCR_SWAP_SHIFT (8) +#define UART_GCR_SWAP_MASK (0x01U << UART_GCR_SWAP_SHIFT) +#define UART_GCR_SWAP(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_SWAP_SHIFT)) & UART_GCR_SWAP_MASK) + +#define UART_GCR_SELB8_SHIFT (7) +#define UART_GCR_SELB8_MASK (0x01U << UART_GCR_SELB8_SHIFT) +#define UART_GCR_SELB8(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_SELB8_SHIFT)) & UART_GCR_SELB8_MASK) + +#define UART_GCR_TXEN_SHIFT (4) +#define UART_GCR_TXEN_MASK (0x01U << UART_GCR_TXEN_SHIFT) +#define UART_GCR_TXEN(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_TXEN_SHIFT)) & UART_GCR_TXEN_MASK) + +#define UART_GCR_RXEN_SHIFT (3) +#define UART_GCR_RXEN_MASK (0x01U << UART_GCR_RXEN_SHIFT) +#define UART_GCR_RXEN(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_RXEN_SHIFT)) & UART_GCR_RXEN_MASK) + +#define UART_GCR_AUTOFLOWEN_SHIFT (2) +#define UART_GCR_AUTOFLOWEN_MASK (0x01U << UART_GCR_AUTOFLOWEN_SHIFT) +#define UART_GCR_AUTOFLOWEN(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_AUTOFLOWEN_SHIFT)) & UART_GCR_AUTOFLOWEN_MASK) + +#define UART_GCR_DMAMODE_SHIFT (1) +#define UART_GCR_DMAMODE_MASK (0x01U << UART_GCR_DMAMODE_SHIFT) +#define UART_GCR_DMAMODE(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_DMAMODE_SHIFT)) & UART_GCR_DMAMODE_MASK) + +#define UART_GCR_UARTEN_SHIFT (0) +#define UART_GCR_UARTEN_MASK (0x01U << UART_GCR_UARTEN_SHIFT) +#define UART_GCR_UARTEN(x) (((uint32_t)(((uint32_t)(x)) << UART_GCR_UARTEN_SHIFT)) & UART_GCR_UARTEN_MASK) + +/*! + * @brief UART_CCR Register Bit Definition + */ + +#define UART_CCR_LIN_SHIFT (14) +#define UART_CCR_LIN_MASK (0x01U << UART_CCR_LIN_SHIFT) +#define UART_CCR_LIN(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_LIN_SHIFT)) & UART_CCR_LIN_MASK) + +#define UART_CCR_WAKE_SHIFT (13) +#define UART_CCR_WAKE_MASK (0x01U << UART_CCR_WAKE_SHIFT) +#define UART_CCR_WAKE(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_WAKE_SHIFT)) & UART_CCR_WAKE_MASK) + +#define UART_CCR_RWU_SHIFT (12) +#define UART_CCR_RWU_MASK (0x01U << UART_CCR_RWU_SHIFT) +#define UART_CCR_RWU(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_RWU_SHIFT)) & UART_CCR_RWU_MASK) + +#define UART_CCR_B8EN_SHIFT (11) +#define UART_CCR_B8EN_MASK (0x01U << UART_CCR_B8EN_SHIFT) +#define UART_CCR_B8EN(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_B8EN_SHIFT)) & UART_CCR_B8EN_MASK) + +#define UART_CCR_B8TOG_SHIFT (10) +#define UART_CCR_B8TOG_MASK (0x01U << UART_CCR_B8TOG_SHIFT) +#define UART_CCR_B8TOG(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_B8TOG_SHIFT)) & UART_CCR_B8TOG_MASK) + +#define UART_CCR_B8POL_SHIFT (9) +#define UART_CCR_B8POL_MASK (0x01U << UART_CCR_B8POL_SHIFT) +#define UART_CCR_B8POL(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_B8POL_SHIFT)) & UART_CCR_B8POL_MASK) + +#define UART_CCR_B8TXD_SHIFT (8) +#define UART_CCR_B8TXD_MASK (0x01U << UART_CCR_B8TXD_SHIFT) +#define UART_CCR_B8TXD(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_B8TXD_SHIFT)) & UART_CCR_B8TXD_MASK) + +#define UART_CCR_B8RXD_SHIFT (7) +#define UART_CCR_B8RXD_MASK (0x01U << UART_CCR_B8RXD_SHIFT) +#define UART_CCR_B8RXD(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_B8RXD_SHIFT)) & UART_CCR_B8RXD_MASK) + +#define UART_CCR_SPB1_SHIFT (6) +#define UART_CCR_SPB1_MASK (0x01U << UART_CCR_SPB1_SHIFT) +#define UART_CCR_SPB1(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_SPB1_SHIFT)) & UART_CCR_SPB1_MASK) + +#define UART_CCR_CHAR_SHIFT (4) +#define UART_CCR_CHAR_MASK (0x3U << UART_CCR_CHAR_SHIFT) +#define UART_CCR_CHAR(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_CHAR_SHIFT)) & UART_CCR_CHAR_MASK) + +#define UART_CCR_BRK_SHIFT (3) +#define UART_CCR_BRK_MASK (0x01U << UART_CCR_BRK_SHIFT) +#define UART_CCR_BRK(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_BRK_SHIFT)) & UART_CCR_BRK_MASK) + +#define UART_CCR_SPB0_SHIFT (2) +#define UART_CCR_SPB0_MASK (0x01U << UART_CCR_SPB0_SHIFT) +#define UART_CCR_SPB0(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_SPB0_SHIFT)) & UART_CCR_SPB0_MASK) + +#define UART_CCR_PSEL_SHIFT (1) +#define UART_CCR_PSEL_MASK (0x01U << UART_CCR_PSEL_SHIFT) +#define UART_CCR_PSEL(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_PSEL_SHIFT)) & UART_CCR_PSEL_MASK) + +#define UART_CCR_PEN_SHIFT (0) +#define UART_CCR_PEN_MASK (0x01U << UART_CCR_PEN_SHIFT) +#define UART_CCR_PEN(x) (((uint32_t)(((uint32_t)(x)) << UART_CCR_PEN_SHIFT)) & UART_CCR_PEN_MASK) + +/*! + * @brief UART_BRR Register Bit Definition + */ + +#define UART_BRR_DIVMANTISSA_SHIFT (0) +#define UART_BRR_DIVMANTISSA_MASK (0xFFFFU << UART_BRR_DIVMANTISSA_SHIFT) +#define UART_BRR_DIVMANTISSA(x) (((uint32_t)(((uint32_t)(x)) << UART_BRR_DIVMANTISSA_SHIFT)) & UART_BRR_DIVMANTISSA_MASK) + +/*! + * @brief UART_FRA Register Bit Definition + */ + +#define UART_FRA_DIVFRACTION_SHIFT (0) +#define UART_FRA_DIVFRACTION_MASK (0xFFFFU << UART_FRA_DIVFRACTION_SHIFT) +#define UART_FRA_DIVFRACTION(x) (((uint32_t)(((uint32_t)(x)) << UART_FRA_DIVFRACTION_SHIFT)) & UART_FRA_DIVFRACTION_MASK) + +/*! + * @brief UART_RXADDR Register Bit Definition + */ + +#define UART_RXADDR_RXADDR_SHIFT (0) +#define UART_RXADDR_RXADDR_MASK (0xFFU << UART_RXADDR_RXADDR_SHIFT) +#define UART_RXADDR_RXADDR(x) (((uint32_t)(((uint32_t)(x)) << UART_RXADDR_RXADDR_SHIFT)) & UART_RXADDR_RXADDR_MASK) + +/*! + * @brief UART_RXMASK Register Bit Definition + */ + +#define UART_RXMASK_RXMASK_SHIFT (0) +#define UART_RXMASK_RXMASK_MASK (0xFFU << UART_RXMASK_RXMASK_SHIFT) +#define UART_RXMASK_RXMASK(x) (((uint32_t)(((uint32_t)(x)) << UART_RXMASK_RXMASK_SHIFT)) & UART_RXMASK_RXMASK_MASK) + +/*! + * @brief UART_SCR Register Bit Definition + */ + +#define UART_SCR_HDSEL_SHIFT (12) +#define UART_SCR_HDSEL_MASK (0x01U << UART_SCR_HDSEL_SHIFT) +#define UART_SCR_HDSEL(x) (((uint32_t)(((uint32_t)(x)) << UART_SCR_HDSEL_SHIFT)) & UART_SCR_HDSEL_MASK) + +#define UART_SCR_SCFCNT_SHIFT (4) +#define UART_SCR_SCFCNT_MASK (0xFFU << UART_SCR_SCFCNT_SHIFT) +#define UART_SCR_SCFCNT(x) (((uint32_t)(((uint32_t)(x)) << UART_SCR_SCFCNT_SHIFT)) & UART_SCR_SCFCNT_MASK) + +#define UART_SCR_NACK_SHIFT (2) +#define UART_SCR_NACK_MASK (0x01U << UART_SCR_NACK_SHIFT) +#define UART_SCR_NACK(x) (((uint32_t)(((uint32_t)(x)) << UART_SCR_NACK_SHIFT)) & UART_SCR_NACK_MASK) + +#define UART_SCR_SCAEN_SHIFT (1) +#define UART_SCR_SCAEN_MASK (0x01U << UART_SCR_SCAEN_SHIFT) +#define UART_SCR_SCAEN(x) (((uint32_t)(((uint32_t)(x)) << UART_SCR_SCAEN_SHIFT)) & UART_SCR_SCAEN_MASK) + +#define UART_SCR_SCEN_SHIFT (0) +#define UART_SCR_SCEN_MASK (0x01U << UART_SCR_SCEN_SHIFT) +#define UART_SCR_SCEN(x) (((uint32_t)(((uint32_t)(x)) << UART_SCR_SCEN_SHIFT)) & UART_SCR_SCEN_MASK) + +/*! + * @brief UART_IDLR Register Bit Definition + */ + +#define UART_IDLR_IDLR_SHIFT (0) +#define UART_IDLR_IDLR_MASK (0xFFFFU << UART_IDLR_IDLR_SHIFT) +#define UART_IDLR_IDLR(x) (((uint32_t)(((uint32_t)(x)) << UART_IDLR_IDLR_SHIFT)) & UART_IDLR_IDLR_MASK) + +/*! + * @brief UART_ABRCR Register Bit Definition + */ + +#define UART_ABRCR_LATTEREDGE_SHIFT (4) +#define UART_ABRCR_LATTEREDGE_MASK (0x01U << UART_ABRCR_LATTEREDGE_SHIFT) +#define UART_ABRCR_LATTEREDGE(x) (((uint32_t)(((uint32_t)(x)) << UART_ABRCR_LATTEREDGE_SHIFT)) & UART_ABRCR_LATTEREDGE_MASK) + +#define UART_ABRCR_FORMEREDGE_SHIFT (3) +#define UART_ABRCR_FORMEREDGE_MASK (0x01U << UART_ABRCR_FORMEREDGE_SHIFT) +#define UART_ABRCR_FORMEREDGE(x) (((uint32_t)(((uint32_t)(x)) << UART_ABRCR_FORMEREDGE_SHIFT)) & UART_ABRCR_FORMEREDGE_MASK) + +#define UART_ABRCR_ABRBITCNT_SHIFT (1) +#define UART_ABRCR_ABRBITCNT_MASK (0x3U << UART_ABRCR_ABRBITCNT_SHIFT) +#define UART_ABRCR_ABRBITCNT(x) (((uint32_t)(((uint32_t)(x)) << UART_ABRCR_ABRBITCNT_SHIFT)) & UART_ABRCR_ABRBITCNT_MASK) + +#define UART_ABRCR_ABREN_SHIFT (0) +#define UART_ABRCR_ABREN_MASK (0x01U << UART_ABRCR_ABREN_SHIFT) +#define UART_ABRCR_ABREN(x) (((uint32_t)(((uint32_t)(x)) << UART_ABRCR_ABREN_SHIFT)) & UART_ABRCR_ABREN_MASK) + +/*! + * @brief UART_IRDA Register Bit Definition + */ + +#define UART_IRDA_PSCREG_SHIFT (8) +#define UART_IRDA_PSCREG_MASK (0xFFU << UART_IRDA_PSCREG_SHIFT) +#define UART_IRDA_PSCREG(x) (((uint32_t)(((uint32_t)(x)) << UART_IRDA_PSCREG_SHIFT)) & UART_IRDA_PSCREG_MASK) + +#define UART_IRDA_SIRLP_SHIFT (1) +#define UART_IRDA_SIRLP_MASK (0x01U << UART_IRDA_SIRLP_SHIFT) +#define UART_IRDA_SIRLP(x) (((uint32_t)(((uint32_t)(x)) << UART_IRDA_SIRLP_SHIFT)) & UART_IRDA_SIRLP_MASK) + +#define UART_IRDA_SIREN_SHIFT (0) +#define UART_IRDA_SIREN_MASK (0x01U << UART_IRDA_SIREN_SHIFT) +#define UART_IRDA_SIREN(x) (((uint32_t)(((uint32_t)(x)) << UART_IRDA_SIREN_SHIFT)) & UART_IRDA_SIREN_MASK) + +/*! + * @} + */ /* end of group UART_Register_Masks */ +/****************************************************************************** + * UART Instance +******************************************************************************/ +#define UART1 ((UART_Type*)UART1_BASE) +#define UART2 ((UART_Type*)UART2_BASE) +#define UART3 ((UART_Type*)UART3_BASE) +#define UART4 ((UART_Type*)UART4_BASE) +#define UART5 ((UART_Type*)UART5_BASE) +#define UART6 ((UART_Type*)UART6_BASE) +#define UART7 ((UART_Type*)UART7_BASE) +#define UART8 ((UART_Type*)UART8_BASE) + +/*! + * @} + */ /* end of group UART_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup SPI_Peripheral_Access_Layer SPI Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * SPI Type + ******************************************************************************/ +typedef struct { + __IO uint32_t TXREG; ///< Send data register offset: 0x00 + __IO uint32_t RXREG; ///< Receive data register offset: 0x04 + __IO uint32_t CSTAT; ///< Current status register offset: 0x08 + __IO uint32_t INTSTAT; ///< Interrupt status register offset: 0x0C + __IO uint32_t INTEN; ///< Interrupt enable register offset: 0x10 + __IO uint32_t INTCLR; ///< Interrupt clear register offset: 0x14 + __IO uint32_t GCTL; ///< Global control register offset: 0x18 + __IO uint32_t CCTL; ///< General control register offset: 0x1C + __IO uint32_t SPBRG; ///< Baud rate generator offset: 0x20 + __IO uint32_t RXDNR; ///< Received data number register offset: 0x24 + __IO uint32_t NSSR; ///< Slave chip select register offset: 0x28 + __IO uint32_t EXTCTL; ///< Data control register offset: 0x2C + __IO uint32_t I2SCFGR; ///< I2S configuration register offset: 0x30 +} SPI_Type; + +/******************************************************************************* + * SPI Type + ******************************************************************************/ + +/*! + * @addtogroup SPI_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief SPI_I2S_TXREG Register Bit Definition + */ + +#define SPI_I2S_TXREG_TXREG_SHIFT (0) +#define SPI_I2S_TXREG_TXREG_MASK (0xFFFFFFFFU << SPI_I2S_TXREG_TXREG_SHIFT) +#define SPI_I2S_TXREG_TXREG(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_TXREG_TXREG_SHIFT)) & SPI_I2S_TXREG_TXREG_MASK) + +/*! + * @brief SPI_I2S_RXREG Register Bit Definition + */ + +#define SPI_I2S_RXREG_RXREG_SHIFT (0) +#define SPI_I2S_RXREG_RXREG_MASK (0xFFFFFFFFU << SPI_I2S_RXREG_RXREG_SHIFT) +#define SPI_I2S_RXREG_RXREG(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_RXREG_RXREG_SHIFT)) & SPI_I2S_RXREG_RXREG_MASK) + +/*! + * @brief SPI_I2S_CSTAT Register Bit Definition + */ + +#define SPI_I2S_CSTAT_CHSIDE_SHIFT (13) +#define SPI_I2S_CSTAT_CHSIDE_MASK (0x01U << SPI_I2S_CSTAT_CHSIDE_SHIFT) +#define SPI_I2S_CSTAT_CHSIDE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_CHSIDE_SHIFT)) & SPI_I2S_CSTAT_CHSIDE_MASK) + +#define SPI_I2S_CSTAT_BUSY_SHIFT (12) +#define SPI_I2S_CSTAT_BUSY_MASK (0x01U << SPI_I2S_CSTAT_BUSY_SHIFT) +#define SPI_I2S_CSTAT_BUSY(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_BUSY_SHIFT)) & SPI_I2S_CSTAT_BUSY_MASK) + +#define SPI_I2S_CSTAT_RXFADDR_SHIFT (8) +#define SPI_I2S_CSTAT_RXFADDR_MASK (0xFU << SPI_I2S_CSTAT_RXFADDR_SHIFT) +#define SPI_I2S_CSTAT_RXFADDR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_RXFADDR_SHIFT)) & SPI_I2S_CSTAT_RXFADDR_MASK) + +#define SPI_I2S_CSTAT_TXFADDR_SHIFT (4) +#define SPI_I2S_CSTAT_TXFADDR_MASK (0xFU << SPI_I2S_CSTAT_TXFADDR_SHIFT) +#define SPI_I2S_CSTAT_TXFADDR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_TXFADDR_SHIFT)) & SPI_I2S_CSTAT_TXFADDR_MASK) + +#define SPI_I2S_CSTAT_RXAVL4BYTE_SHIFT (3) +#define SPI_I2S_CSTAT_RXAVL4BYTE_MASK (0x01U << SPI_I2S_CSTAT_RXAVL4BYTE_SHIFT) +#define SPI_I2S_CSTAT_RXAVL4BYTE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_RXAVL4BYTE_SHIFT)) & SPI_I2S_CSTAT_RXAVL4BYTE_MASK) + +#define SPI_I2S_CSTAT_TXFULL_SHIFT (2) +#define SPI_I2S_CSTAT_TXFULL_MASK (0x01U << SPI_I2S_CSTAT_TXFULL_SHIFT) +#define SPI_I2S_CSTAT_TXFULL(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_TXFULL_SHIFT)) & SPI_I2S_CSTAT_TXFULL_MASK) + +#define SPI_I2S_CSTAT_RXAVL_SHIFT (1) +#define SPI_I2S_CSTAT_RXAVL_MASK (0x01U << SPI_I2S_CSTAT_RXAVL_SHIFT) +#define SPI_I2S_CSTAT_RXAVL(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_RXAVL_SHIFT)) & SPI_I2S_CSTAT_RXAVL_MASK) + +#define SPI_I2S_CSTAT_TXEPT_SHIFT (0) +#define SPI_I2S_CSTAT_TXEPT_MASK (0x01U << SPI_I2S_CSTAT_TXEPT_SHIFT) +#define SPI_I2S_CSTAT_TXEPT(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CSTAT_TXEPT_SHIFT)) & SPI_I2S_CSTAT_TXEPT_MASK) + +/*! + * @brief SPI_I2S_INTSTAT Register Bit Definition + */ + +#define SPI_I2S_INTSTAT_FREINTF_SHIFT (7) +#define SPI_I2S_INTSTAT_FREINTF_MASK (0x01U << SPI_I2S_INTSTAT_FREINTF_SHIFT) +#define SPI_I2S_INTSTAT_FREINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_FREINTF_SHIFT)) & SPI_I2S_INTSTAT_FREINTF_MASK) + +#define SPI_I2S_INTSTAT_TXEPTINTF_SHIFT (6) +#define SPI_I2S_INTSTAT_TXEPTINTF_MASK (0x01U << SPI_I2S_INTSTAT_TXEPTINTF_SHIFT) +#define SPI_I2S_INTSTAT_TXEPTINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_TXEPTINTF_SHIFT)) & SPI_I2S_INTSTAT_TXEPTINTF_MASK) + +#define SPI_I2S_INTSTAT_RXFULLINTF_SHIFT (5) +#define SPI_I2S_INTSTAT_RXFULLINTF_MASK (0x01U << SPI_I2S_INTSTAT_RXFULLINTF_SHIFT) +#define SPI_I2S_INTSTAT_RXFULLINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_RXFULLINTF_SHIFT)) & SPI_I2S_INTSTAT_RXFULLINTF_MASK) + +#define SPI_I2S_INTSTAT_RXMATCHINTF_SHIFT (4) +#define SPI_I2S_INTSTAT_RXMATCHINTF_MASK (0x01U << SPI_I2S_INTSTAT_RXMATCHINTF_SHIFT) +#define SPI_I2S_INTSTAT_RXMATCHINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_RXMATCHINTF_SHIFT)) & SPI_I2S_INTSTAT_RXMATCHINTF_MASK) + +#define SPI_I2S_INTSTAT_RXOERRINTF_SHIFT (3) +#define SPI_I2S_INTSTAT_RXOERRINTF_MASK (0x01U << SPI_I2S_INTSTAT_RXOERRINTF_SHIFT) +#define SPI_I2S_INTSTAT_RXOERRINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_RXOERRINTF_SHIFT)) & SPI_I2S_INTSTAT_RXOERRINTF_MASK) + +#define SPI_I2S_INTSTAT_UNDERRUNINTF_SHIFT (2) +#define SPI_I2S_INTSTAT_UNDERRUNINTF_MASK (0x01U << SPI_I2S_INTSTAT_UNDERRUNINTF_SHIFT) +#define SPI_I2S_INTSTAT_UNDERRUNINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_UNDERRUNINTF_SHIFT)) & SPI_I2S_INTSTAT_UNDERRUNINTF_MASK) + +#define SPI_I2S_INTSTAT_RXINTF_SHIFT (1) +#define SPI_I2S_INTSTAT_RXINTF_MASK (0x01U << SPI_I2S_INTSTAT_RXINTF_SHIFT) +#define SPI_I2S_INTSTAT_RXINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_RXINTF_SHIFT)) & SPI_I2S_INTSTAT_RXINTF_MASK) + +#define SPI_I2S_INTSTAT_TXINTF_SHIFT (0) +#define SPI_I2S_INTSTAT_TXINTF_MASK (0x01U << SPI_I2S_INTSTAT_TXINTF_SHIFT) +#define SPI_I2S_INTSTAT_TXINTF(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTSTAT_TXINTF_SHIFT)) & SPI_I2S_INTSTAT_TXINTF_MASK) + +/*! + * @brief SPI_I2S_INTEN Register Bit Definition + */ + +#define SPI_I2S_INTEN_FREIEN_SHIFT (7) +#define SPI_I2S_INTEN_FREIEN_MASK (0x01U << SPI_I2S_INTEN_FREIEN_SHIFT) +#define SPI_I2S_INTEN_FREIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_FREIEN_SHIFT)) & SPI_I2S_INTEN_FREIEN_MASK) + +#define SPI_I2S_INTEN_TXEPTIEN_SHIFT (6) +#define SPI_I2S_INTEN_TXEPTIEN_MASK (0x01U << SPI_I2S_INTEN_TXEPTIEN_SHIFT) +#define SPI_I2S_INTEN_TXEPTIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_TXEPTIEN_SHIFT)) & SPI_I2S_INTEN_TXEPTIEN_MASK) + +#define SPI_I2S_INTEN_RXFULLIEN_SHIFT (5) +#define SPI_I2S_INTEN_RXFULLIEN_MASK (0x01U << SPI_I2S_INTEN_RXFULLIEN_SHIFT) +#define SPI_I2S_INTEN_RXFULLIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_RXFULLIEN_SHIFT)) & SPI_I2S_INTEN_RXFULLIEN_MASK) + +#define SPI_I2S_INTEN_RXMATCHIEN_SHIFT (4) +#define SPI_I2S_INTEN_RXMATCHIEN_MASK (0x01U << SPI_I2S_INTEN_RXMATCHIEN_SHIFT) +#define SPI_I2S_INTEN_RXMATCHIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_RXMATCHIEN_SHIFT)) & SPI_I2S_INTEN_RXMATCHIEN_MASK) + +#define SPI_I2S_INTEN_RXOERRIEN_SHIFT (3) +#define SPI_I2S_INTEN_RXOERRIEN_MASK (0x01U << SPI_I2S_INTEN_RXOERRIEN_SHIFT) +#define SPI_I2S_INTEN_RXOERRIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_RXOERRIEN_SHIFT)) & SPI_I2S_INTEN_RXOERRIEN_MASK) + +#define SPI_I2S_INTEN_UNDERRUNIEN_SHIFT (2) +#define SPI_I2S_INTEN_UNDERRUNIEN_MASK (0x01U << SPI_I2S_INTEN_UNDERRUNIEN_SHIFT) +#define SPI_I2S_INTEN_UNDERRUNIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_UNDERRUNIEN_SHIFT)) & SPI_I2S_INTEN_UNDERRUNIEN_MASK) + +#define SPI_I2S_INTEN_RXIEN_SHIFT (1) +#define SPI_I2S_INTEN_RXIEN_MASK (0x01U << SPI_I2S_INTEN_RXIEN_SHIFT) +#define SPI_I2S_INTEN_RXIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_RXIEN_SHIFT)) & SPI_I2S_INTEN_RXIEN_MASK) + +#define SPI_I2S_INTEN_TXIEN_SHIFT (0) +#define SPI_I2S_INTEN_TXIEN_MASK (0x01U << SPI_I2S_INTEN_TXIEN_SHIFT) +#define SPI_I2S_INTEN_TXIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTEN_TXIEN_SHIFT)) & SPI_I2S_INTEN_TXIEN_MASK) + +/*! + * @brief SPI_I2S_INTCLR Register Bit Definition + */ + +#define SPI_I2S_INTCLR_FREICLR_SHIFT (7) +#define SPI_I2S_INTCLR_FREICLR_MASK (0x01U << SPI_I2S_INTCLR_FREICLR_SHIFT) +#define SPI_I2S_INTCLR_FREICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_FREICLR_SHIFT)) & SPI_I2S_INTCLR_FREICLR_MASK) + +#define SPI_I2S_INTCLR_TXEPTICLR_SHIFT (6) +#define SPI_I2S_INTCLR_TXEPTICLR_MASK (0x01U << SPI_I2S_INTCLR_TXEPTICLR_SHIFT) +#define SPI_I2S_INTCLR_TXEPTICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_TXEPTICLR_SHIFT)) & SPI_I2S_INTCLR_TXEPTICLR_MASK) + +#define SPI_I2S_INTCLR_RXFULLICLR_SHIFT (5) +#define SPI_I2S_INTCLR_RXFULLICLR_MASK (0x01U << SPI_I2S_INTCLR_RXFULLICLR_SHIFT) +#define SPI_I2S_INTCLR_RXFULLICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_RXFULLICLR_SHIFT)) & SPI_I2S_INTCLR_RXFULLICLR_MASK) + +#define SPI_I2S_INTCLR_RXMATCHICLR_SHIFT (4) +#define SPI_I2S_INTCLR_RXMATCHICLR_MASK (0x01U << SPI_I2S_INTCLR_RXMATCHICLR_SHIFT) +#define SPI_I2S_INTCLR_RXMATCHICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_RXMATCHICLR_SHIFT)) & SPI_I2S_INTCLR_RXMATCHICLR_MASK) + +#define SPI_I2S_INTCLR_RXOERRICLR_SHIFT (3) +#define SPI_I2S_INTCLR_RXOERRICLR_MASK (0x01U << SPI_I2S_INTCLR_RXOERRICLR_SHIFT) +#define SPI_I2S_INTCLR_RXOERRICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_RXOERRICLR_SHIFT)) & SPI_I2S_INTCLR_RXOERRICLR_MASK) + +#define SPI_I2S_INTCLR_UNDERRUNICLR_SHIFT (2) +#define SPI_I2S_INTCLR_UNDERRUNICLR_MASK (0x01U << SPI_I2S_INTCLR_UNDERRUNICLR_SHIFT) +#define SPI_I2S_INTCLR_UNDERRUNICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_UNDERRUNICLR_SHIFT)) & SPI_I2S_INTCLR_UNDERRUNICLR_MASK) + +#define SPI_I2S_INTCLR_RXICLR_SHIFT (1) +#define SPI_I2S_INTCLR_RXICLR_MASK (0x01U << SPI_I2S_INTCLR_RXICLR_SHIFT) +#define SPI_I2S_INTCLR_RXICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_RXICLR_SHIFT)) & SPI_I2S_INTCLR_RXICLR_MASK) + +#define SPI_I2S_INTCLR_TXICLR_SHIFT (0) +#define SPI_I2S_INTCLR_TXICLR_MASK (0x01U << SPI_I2S_INTCLR_TXICLR_SHIFT) +#define SPI_I2S_INTCLR_TXICLR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_INTCLR_TXICLR_SHIFT)) & SPI_I2S_INTCLR_TXICLR_MASK) + +/*! + * @brief SPI_I2S_GCTL Register Bit Definition + */ + +#define SPI_I2S_GCTL_PADSEL_SHIFT (13) +#define SPI_I2S_GCTL_PADSEL_MASK (0x1FU << SPI_I2S_GCTL_PADSEL_SHIFT) +#define SPI_I2S_GCTL_PADSEL(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_PADSEL_SHIFT)) & SPI_I2S_GCTL_PADSEL_MASK) + +#define SPI_I2S_GCTL_NSSTOG_SHIFT (12) +#define SPI_I2S_GCTL_NSSTOG_MASK (0x01U << SPI_I2S_GCTL_NSSTOG_SHIFT) +#define SPI_I2S_GCTL_NSSTOG(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_NSSTOG_SHIFT)) & SPI_I2S_GCTL_NSSTOG_MASK) + +#define SPI_I2S_GCTL_DW832_SHIFT (11) +#define SPI_I2S_GCTL_DW832_MASK (0x01U << SPI_I2S_GCTL_DW832_SHIFT) +#define SPI_I2S_GCTL_DW832(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_DW832_SHIFT)) & SPI_I2S_GCTL_DW832_MASK) + +#define SPI_I2S_GCTL_NSS_SHIFT (10) +#define SPI_I2S_GCTL_NSS_MASK (0x01U << SPI_I2S_GCTL_NSS_SHIFT) +#define SPI_I2S_GCTL_NSS(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_NSS_SHIFT)) & SPI_I2S_GCTL_NSS_MASK) + +#define SPI_I2S_GCTL_DMAMODE_SHIFT (9) +#define SPI_I2S_GCTL_DMAMODE_MASK (0x01U << SPI_I2S_GCTL_DMAMODE_SHIFT) +#define SPI_I2S_GCTL_DMAMODE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_DMAMODE_SHIFT)) & SPI_I2S_GCTL_DMAMODE_MASK) + +#define SPI_I2S_GCTL_RXEN_SHIFT (4) +#define SPI_I2S_GCTL_RXEN_MASK (0x01U << SPI_I2S_GCTL_RXEN_SHIFT) +#define SPI_I2S_GCTL_RXEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_RXEN_SHIFT)) & SPI_I2S_GCTL_RXEN_MASK) + +#define SPI_I2S_GCTL_TXEN_SHIFT (3) +#define SPI_I2S_GCTL_TXEN_MASK (0x01U << SPI_I2S_GCTL_TXEN_SHIFT) +#define SPI_I2S_GCTL_TXEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_TXEN_SHIFT)) & SPI_I2S_GCTL_TXEN_MASK) + +#define SPI_I2S_GCTL_MODE_SHIFT (2) +#define SPI_I2S_GCTL_MODE_MASK (0x01U << SPI_I2S_GCTL_MODE_SHIFT) +#define SPI_I2S_GCTL_MODE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_MODE_SHIFT)) & SPI_I2S_GCTL_MODE_MASK) + +#define SPI_I2S_GCTL_INTEN_SHIFT (1) +#define SPI_I2S_GCTL_INTEN_MASK (0x01U << SPI_I2S_GCTL_INTEN_SHIFT) +#define SPI_I2S_GCTL_INTEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_INTEN_SHIFT)) & SPI_I2S_GCTL_INTEN_MASK) + +#define SPI_I2S_GCTL_SPIEN_SHIFT (0) +#define SPI_I2S_GCTL_SPIEN_MASK (0x01U << SPI_I2S_GCTL_SPIEN_SHIFT) +#define SPI_I2S_GCTL_SPIEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_GCTL_SPIEN_SHIFT)) & SPI_I2S_GCTL_SPIEN_MASK) + +/*! + * @brief SPI_I2S_CCTL Register Bit Definition + */ + +#define SPI_I2S_CCTL_CPHASEL_SHIFT (6) +#define SPI_I2S_CCTL_CPHASEL_MASK (0x01U << SPI_I2S_CCTL_CPHASEL_SHIFT) +#define SPI_I2S_CCTL_CPHASEL(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CCTL_CPHASEL_SHIFT)) & SPI_I2S_CCTL_CPHASEL_MASK) + +#define SPI_I2S_CCTL_TXEDGE_SHIFT (5) +#define SPI_I2S_CCTL_TXEDGE_MASK (0x01U << SPI_I2S_CCTL_TXEDGE_SHIFT) +#define SPI_I2S_CCTL_TXEDGE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CCTL_TXEDGE_SHIFT)) & SPI_I2S_CCTL_TXEDGE_MASK) + +#define SPI_I2S_CCTL_RXEDGE_SHIFT (4) +#define SPI_I2S_CCTL_RXEDGE_MASK (0x01U << SPI_I2S_CCTL_RXEDGE_SHIFT) +#define SPI_I2S_CCTL_RXEDGE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CCTL_RXEDGE_SHIFT)) & SPI_I2S_CCTL_RXEDGE_MASK) + +#define SPI_I2S_CCTL_SPILEN_SHIFT (3) +#define SPI_I2S_CCTL_SPILEN_MASK (0x01U << SPI_I2S_CCTL_SPILEN_SHIFT) +#define SPI_I2S_CCTL_SPILEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CCTL_SPILEN_SHIFT)) & SPI_I2S_CCTL_SPILEN_MASK) + +#define SPI_I2S_CCTL_LSBFE_SHIFT (2) +#define SPI_I2S_CCTL_LSBFE_MASK (0x01U << SPI_I2S_CCTL_LSBFE_SHIFT) +#define SPI_I2S_CCTL_LSBFE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CCTL_LSBFE_SHIFT)) & SPI_I2S_CCTL_LSBFE_MASK) + +#define SPI_I2S_CCTL_CPOL_SHIFT (1) +#define SPI_I2S_CCTL_CPOL_MASK (0x01U << SPI_I2S_CCTL_CPOL_SHIFT) +#define SPI_I2S_CCTL_CPOL(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CCTL_CPOL_SHIFT)) & SPI_I2S_CCTL_CPOL_MASK) + +#define SPI_I2S_CCTL_CPHA_SHIFT (0) +#define SPI_I2S_CCTL_CPHA_MASK (0x01U << SPI_I2S_CCTL_CPHA_SHIFT) +#define SPI_I2S_CCTL_CPHA(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_CCTL_CPHA_SHIFT)) & SPI_I2S_CCTL_CPHA_MASK) + +/*! + * @brief SPI_I2S_SPBRG Register Bit Definition + */ + +#define SPI_I2S_SPBRG_SPBRG_SHIFT (0) +#define SPI_I2S_SPBRG_SPBRG_MASK (0xFFFFU << SPI_I2S_SPBRG_SPBRG_SHIFT) +#define SPI_I2S_SPBRG_SPBRG(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_SPBRG_SPBRG_SHIFT)) & SPI_I2S_SPBRG_SPBRG_MASK) + +/*! + * @brief SPI_I2S_RXDNR Register Bit Definition + */ + +#define SPI_I2S_RXDNR_RXDNR_SHIFT (0) +#define SPI_I2S_RXDNR_RXDNR_MASK (0xFFFFU << SPI_I2S_RXDNR_RXDNR_SHIFT) +#define SPI_I2S_RXDNR_RXDNR(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_RXDNR_RXDNR_SHIFT)) & SPI_I2S_RXDNR_RXDNR_MASK) + +/*! + * @brief SPI_I2S_NSSR Register Bit Definition + */ + +#define SPI_I2S_NSSR_NSS_SHIFT (0) +#define SPI_I2S_NSSR_NSS_MASK (0x01U << SPI_I2S_NSSR_NSS_SHIFT) +#define SPI_I2S_NSSR_NSS(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_NSSR_NSS_SHIFT)) & SPI_I2S_NSSR_NSS_MASK) + +/*! + * @brief SPI_I2S_EXTCTL Register Bit Definition + */ + +#define SPI_I2S_EXTCTL_EXTLEN_SHIFT (0) +#define SPI_I2S_EXTCTL_EXTLEN_MASK (0x1FU << SPI_I2S_EXTCTL_EXTLEN_SHIFT) +#define SPI_I2S_EXTCTL_EXTLEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_EXTCTL_EXTLEN_SHIFT)) & SPI_I2S_EXTCTL_EXTLEN_MASK) + +/*! + * @brief SPI_I2S_I2SCFGR Register Bit Definition + */ + +#define SPI_I2S_I2SCFGR_I2SDIV_SHIFT (16) +#define SPI_I2S_I2SCFGR_I2SDIV_MASK (0x1FFU << SPI_I2S_I2SCFGR_I2SDIV_SHIFT) +#define SPI_I2S_I2SCFGR_I2SDIV(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_I2SCFGR_I2SDIV_SHIFT)) & SPI_I2S_I2SCFGR_I2SDIV_MASK) + +#define SPI_I2S_I2SCFGR_MCKOE_SHIFT (11) +#define SPI_I2S_I2SCFGR_MCKOE_MASK (0x01U << SPI_I2S_I2SCFGR_MCKOE_SHIFT) +#define SPI_I2S_I2SCFGR_MCKOE(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_I2SCFGR_MCKOE_SHIFT)) & SPI_I2S_I2SCFGR_MCKOE_MASK) + +#define SPI_I2S_I2SCFGR_SPII2S_SHIFT (10) +#define SPI_I2S_I2SCFGR_SPII2S_MASK (0x01U << SPI_I2S_I2SCFGR_SPII2S_SHIFT) +#define SPI_I2S_I2SCFGR_SPII2S(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_I2SCFGR_SPII2S_SHIFT)) & SPI_I2S_I2SCFGR_SPII2S_MASK) + +#define SPI_I2S_I2SCFGR_PCMSYNC_SHIFT (6) +#define SPI_I2S_I2SCFGR_PCMSYNC_MASK (0x01U << SPI_I2S_I2SCFGR_PCMSYNC_SHIFT) +#define SPI_I2S_I2SCFGR_PCMSYNC(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_I2SCFGR_PCMSYNC_SHIFT)) & SPI_I2S_I2SCFGR_PCMSYNC_MASK) + +#define SPI_I2S_I2SCFGR_I2SSTD_SHIFT (4) +#define SPI_I2S_I2SCFGR_I2SSTD_MASK (0x3U << SPI_I2S_I2SCFGR_I2SSTD_SHIFT) +#define SPI_I2S_I2SCFGR_I2SSTD(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_I2SCFGR_I2SSTD_SHIFT)) & SPI_I2S_I2SCFGR_I2SSTD_MASK) + +#define SPI_I2S_I2SCFGR_DATLEN_SHIFT (1) +#define SPI_I2S_I2SCFGR_DATLEN_MASK (0x3U << SPI_I2S_I2SCFGR_DATLEN_SHIFT) +#define SPI_I2S_I2SCFGR_DATLEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_I2SCFGR_DATLEN_SHIFT)) & SPI_I2S_I2SCFGR_DATLEN_MASK) + +#define SPI_I2S_I2SCFGR_CHLEN_SHIFT (0) +#define SPI_I2S_I2SCFGR_CHLEN_MASK (0x01U << SPI_I2S_I2SCFGR_CHLEN_SHIFT) +#define SPI_I2S_I2SCFGR_CHLEN(x) (((uint32_t)(((uint32_t)(x)) << SPI_I2S_I2SCFGR_CHLEN_SHIFT)) & SPI_I2S_I2SCFGR_CHLEN_MASK) + +/*! + * @} + */ /* end of group SPI_Register_Masks */ +/****************************************************************************** + * SPI Instance +******************************************************************************/ +#define SPI1 ((SPI_Type*)SPI1_BASE) +#define SPI2 ((SPI_Type*)SPI2_BASE) +#define SPI3 ((SPI_Type*)SPI3_BASE) + +/*! + * @} + */ /* end of group SPI_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup I2C_Peripheral_Access_Layer I2C Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * I2C Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR; ///< I2C control register offset: 0x00 + __IO uint32_t TAR; ///< I2C target address register offset: 0x04 + __IO uint32_t SAR; ///< I2C slave address register offset: 0x08 + __IO uint32_t Reserved14[1]; ///< Reserved + __IO uint32_t DR; ///< I2C data command register offset: 0x10 + __IO uint32_t SSHR; ///< Standard mode I2C clock high level count registeroffset: 0x14 + __IO uint32_t SSLR; ///< Standard mode I2C clock low count register offset: 0x18 + __IO uint32_t FSHR; ///< Fast mode I2C clock high level count registeroffset: 0x1C + __IO uint32_t FSLR; ///< Fast mode I2C clock low count register offset: 0x20 + __IO uint32_t Reserved15[2]; ///< Reserved + __IO uint32_t ISR; ///< I2C interrupt status register offset: 0x2C + __IO uint32_t IMR; ///< I2C interrupt mask register offset: 0x30 + __IO uint32_t RAWISR; ///< I2C RAW interrupt register offset: 0x34 + __IO uint32_t RXTLR; ///< I2C receive threshold offset: 0x38 + __IO uint32_t TXTLR; ///< I2C send threshold offset: 0x3C + __IO uint32_t ICR; ///< I2C combination and independent interrupt clear registeroffset: 0x40 + __IO uint32_t RXUNDER; ///< I2C clears the RXUNDER interrupt register offset: 0x44 + __IO uint32_t RXOVER; ///< I2C clears the RXOVER interrupt register offset: 0x48 + __IO uint32_t TXOVER; ///< I2C clear TXOVER interrupt register offset: 0x4C + __IO uint32_t RDREQ; ///< I2C clears the RDREQ interrupt register offset: 0x50 + __IO uint32_t TXABRT; ///< I2C clear TXABRT interrupt register offset: 0x54 + __IO uint32_t RXDONE; ///< I2C clears the RXDONE interrupt register offset: 0x58 + __IO uint32_t ACTIV; ///< I2C clears the ACTIVITY interrupt register offset: 0x5C + __IO uint32_t STOP; ///< I2C clears the STOP_DET interrupt register offset: 0x60 + __IO uint32_t START; ///< I2C clears the START_DET interrupt register offset: 0x64 + __IO uint32_t GC; ///< I2C clears the GEN_CALL interrupt register offset: 0x68 + __IO uint32_t ENR; ///< I2C enable register offset: 0x6C + __IO uint32_t SR; ///< I2C status register offset: 0x70 + __IO uint32_t TXFLR; ///< I2C transmit buffer level register offset: 0x74 + __IO uint32_t RXFLR; ///< I2C receive buffer level register offset: 0x78 + __IO uint32_t HOLD; ///< I2C SDA hold time register offset: 0x7C + __IO uint32_t Reserved16[2]; ///< Reserved + __IO uint32_t DMA; ///< I2C DMA control register offset: 0x88 + __IO uint32_t Reserved17[2]; ///< Reserved + __IO uint32_t SETUP; ///< I2C SDA Setup Time Register offset: 0x94 + __IO uint32_t GCR; ///< I2C general call ACK register offset: 0x98 + __IO uint32_t Reserved18[5]; ///< Reserved + __IO uint32_t SLVMASK; ///< I2C slave address mask register offset: 0xB0 + __IO uint32_t SLVRCVADDR; ///< I2C slave receiver address register offset: 0xB4 +} I2C_Type; + +/******************************************************************************* + * I2C Type + ******************************************************************************/ + +/*! + * @addtogroup I2C_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief I2C_CR Register Bit Definition + */ + +#define I2C_CR_SLVTXABRTDIS_SHIFT (11) +#define I2C_CR_SLVTXABRTDIS_MASK (0x01U << I2C_CR_SLVTXABRTDIS_SHIFT) +#define I2C_CR_SLVTXABRTDIS(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_SLVTXABRTDIS_SHIFT)) & I2C_CR_SLVTXABRTDIS_MASK) + +#define I2C_CR_RESTART_SHIFT (10) +#define I2C_CR_RESTART_MASK (0x01U << I2C_CR_RESTART_SHIFT) +#define I2C_CR_RESTART(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_RESTART_SHIFT)) & I2C_CR_RESTART_MASK) + +#define I2C_CR_STOP_SHIFT (9) +#define I2C_CR_STOP_MASK (0x01U << I2C_CR_STOP_SHIFT) +#define I2C_CR_STOP(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_STOP_SHIFT)) & I2C_CR_STOP_MASK) + +#define I2C_CR_EMPINT_SHIFT (8) +#define I2C_CR_EMPINT_MASK (0x01U << I2C_CR_EMPINT_SHIFT) +#define I2C_CR_EMPINT(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_EMPINT_SHIFT)) & I2C_CR_EMPINT_MASK) + +#define I2C_CR_STOPINT_SHIFT (7) +#define I2C_CR_STOPINT_MASK (0x01U << I2C_CR_STOPINT_SHIFT) +#define I2C_CR_STOPINT(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_STOPINT_SHIFT)) & I2C_CR_STOPINT_MASK) + +#define I2C_CR_DISSLAVE_SHIFT (6) +#define I2C_CR_DISSLAVE_MASK (0x01U << I2C_CR_DISSLAVE_SHIFT) +#define I2C_CR_DISSLAVE(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_DISSLAVE_SHIFT)) & I2C_CR_DISSLAVE_MASK) + +#define I2C_CR_REPEN_SHIFT (5) +#define I2C_CR_REPEN_MASK (0x01U << I2C_CR_REPEN_SHIFT) +#define I2C_CR_REPEN(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_REPEN_SHIFT)) & I2C_CR_REPEN_MASK) + +#define I2C_CR_MASTER10_SHIFT (4) +#define I2C_CR_MASTER10_MASK (0x01U << I2C_CR_MASTER10_SHIFT) +#define I2C_CR_MASTER10(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_MASTER10_SHIFT)) & I2C_CR_MASTER10_MASK) + +#define I2C_CR_SLAVE10_SHIFT (3) +#define I2C_CR_SLAVE10_MASK (0x01U << I2C_CR_SLAVE10_SHIFT) +#define I2C_CR_SLAVE10(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_SLAVE10_SHIFT)) & I2C_CR_SLAVE10_MASK) + +#define I2C_CR_SPEED_SHIFT (1) +#define I2C_CR_SPEED_MASK (0x3U << I2C_CR_SPEED_SHIFT) +#define I2C_CR_SPEED(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_SPEED_SHIFT)) & I2C_CR_SPEED_MASK) + +#define I2C_CR_MASTER_SHIFT (0) +#define I2C_CR_MASTER_MASK (0x01U << I2C_CR_MASTER_SHIFT) +#define I2C_CR_MASTER(x) (((uint32_t)(((uint32_t)(x)) << I2C_CR_MASTER_SHIFT)) & I2C_CR_MASTER_MASK) + +/*! + * @brief I2C_TAR Register Bit Definition + */ + +#define I2C_TAR_SPECIAL_SHIFT (11) +#define I2C_TAR_SPECIAL_MASK (0x01U << I2C_TAR_SPECIAL_SHIFT) +#define I2C_TAR_SPECIAL(x) (((uint32_t)(((uint32_t)(x)) << I2C_TAR_SPECIAL_SHIFT)) & I2C_TAR_SPECIAL_MASK) + +#define I2C_TAR_GC_SHIFT (10) +#define I2C_TAR_GC_MASK (0x01U << I2C_TAR_GC_SHIFT) +#define I2C_TAR_GC(x) (((uint32_t)(((uint32_t)(x)) << I2C_TAR_GC_SHIFT)) & I2C_TAR_GC_MASK) + +#define I2C_TAR_ADDR_SHIFT (0) +#define I2C_TAR_ADDR_MASK (0x3FFU << I2C_TAR_ADDR_SHIFT) +#define I2C_TAR_ADDR(x) (((uint32_t)(((uint32_t)(x)) << I2C_TAR_ADDR_SHIFT)) & I2C_TAR_ADDR_MASK) + +/*! + * @brief I2C_SAR Register Bit Definition + */ + +#define I2C_SAR_ADDR_SHIFT (0) +#define I2C_SAR_ADDR_MASK (0x3FFU << I2C_SAR_ADDR_SHIFT) +#define I2C_SAR_ADDR(x) (((uint32_t)(((uint32_t)(x)) << I2C_SAR_ADDR_SHIFT)) & I2C_SAR_ADDR_MASK) + +/*! + * @brief I2C_DR Register Bit Definition + */ + +#define I2C_DR_CMD_SHIFT (8) +#define I2C_DR_CMD_MASK (0x01U << I2C_DR_CMD_SHIFT) +#define I2C_DR_CMD(x) (((uint32_t)(((uint32_t)(x)) << I2C_DR_CMD_SHIFT)) & I2C_DR_CMD_MASK) + +#define I2C_DR_DAT_SHIFT (0) +#define I2C_DR_DAT_MASK (0xFFU << I2C_DR_DAT_SHIFT) +#define I2C_DR_DAT(x) (((uint32_t)(((uint32_t)(x)) << I2C_DR_DAT_SHIFT)) & I2C_DR_DAT_MASK) + +/*! + * @brief I2C_SSHR Register Bit Definition + */ + +#define I2C_SSHR_CNT_SHIFT (0) +#define I2C_SSHR_CNT_MASK (0xFFFFU << I2C_SSHR_CNT_SHIFT) +#define I2C_SSHR_CNT(x) (((uint32_t)(((uint32_t)(x)) << I2C_SSHR_CNT_SHIFT)) & I2C_SSHR_CNT_MASK) + +/*! + * @brief I2C_SSLR Register Bit Definition + */ + +#define I2C_SSLR_CNT_SHIFT (0) +#define I2C_SSLR_CNT_MASK (0xFFFFU << I2C_SSLR_CNT_SHIFT) +#define I2C_SSLR_CNT(x) (((uint32_t)(((uint32_t)(x)) << I2C_SSLR_CNT_SHIFT)) & I2C_SSLR_CNT_MASK) + +/*! + * @brief I2C_FSHR Register Bit Definition + */ + +#define I2C_FSHR_CNT_SHIFT (0) +#define I2C_FSHR_CNT_MASK (0xFFFFU << I2C_FSHR_CNT_SHIFT) +#define I2C_FSHR_CNT(x) (((uint32_t)(((uint32_t)(x)) << I2C_FSHR_CNT_SHIFT)) & I2C_FSHR_CNT_MASK) + +/*! + * @brief I2C_FSLR Register Bit Definition + */ + +#define I2C_FSLR_CNT_SHIFT (0) +#define I2C_FSLR_CNT_MASK (0xFFFFU << I2C_FSLR_CNT_SHIFT) +#define I2C_FSLR_CNT(x) (((uint32_t)(((uint32_t)(x)) << I2C_FSLR_CNT_SHIFT)) & I2C_FSLR_CNT_MASK) + +/*! + * @brief I2C_ISR Register Bit Definition + */ + +#define I2C_ISR_ISR_SHIFT (0) +#define I2C_ISR_ISR_MASK (0xFFFU << I2C_ISR_ISR_SHIFT) +#define I2C_ISR_ISR(x) (((uint32_t)(((uint32_t)(x)) << I2C_ISR_ISR_SHIFT)) & I2C_ISR_ISR_MASK) + +/*! + * @brief I2C_IMR Register Bit Definition + */ + +#define I2C_IMR_IMR_SHIFT (0) +#define I2C_IMR_IMR_MASK (0xFFFU << I2C_IMR_IMR_SHIFT) +#define I2C_IMR_IMR(x) (((uint32_t)(((uint32_t)(x)) << I2C_IMR_IMR_SHIFT)) & I2C_IMR_IMR_MASK) + +/*! + * @brief I2C_RAWISR Register Bit Definition + */ + +#define I2C_RAWISR_GC_SHIFT (11) +#define I2C_RAWISR_GC_MASK (0x01U << I2C_RAWISR_GC_SHIFT) +#define I2C_RAWISR_GC(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_GC_SHIFT)) & I2C_RAWISR_GC_MASK) + +#define I2C_RAWISR_START_SHIFT (10) +#define I2C_RAWISR_START_MASK (0x01U << I2C_RAWISR_START_SHIFT) +#define I2C_RAWISR_START(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_START_SHIFT)) & I2C_RAWISR_START_MASK) + +#define I2C_RAWISR_STOP_SHIFT (9) +#define I2C_RAWISR_STOP_MASK (0x01U << I2C_RAWISR_STOP_SHIFT) +#define I2C_RAWISR_STOP(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_STOP_SHIFT)) & I2C_RAWISR_STOP_MASK) + +#define I2C_RAWISR_ACTIV_SHIFT (8) +#define I2C_RAWISR_ACTIV_MASK (0x01U << I2C_RAWISR_ACTIV_SHIFT) +#define I2C_RAWISR_ACTIV(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_ACTIV_SHIFT)) & I2C_RAWISR_ACTIV_MASK) + +#define I2C_RAWISR_RXDONE_SHIFT (7) +#define I2C_RAWISR_RXDONE_MASK (0x01U << I2C_RAWISR_RXDONE_SHIFT) +#define I2C_RAWISR_RXDONE(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_RXDONE_SHIFT)) & I2C_RAWISR_RXDONE_MASK) + +#define I2C_RAWISR_TXABRT_SHIFT (6) +#define I2C_RAWISR_TXABRT_MASK (0x01U << I2C_RAWISR_TXABRT_SHIFT) +#define I2C_RAWISR_TXABRT(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_TXABRT_SHIFT)) & I2C_RAWISR_TXABRT_MASK) + +#define I2C_RAWISR_RDREQ_SHIFT (5) +#define I2C_RAWISR_RDREQ_MASK (0x01U << I2C_RAWISR_RDREQ_SHIFT) +#define I2C_RAWISR_RDREQ(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_RDREQ_SHIFT)) & I2C_RAWISR_RDREQ_MASK) + +#define I2C_RAWISR_TXEMPTY_SHIFT (4) +#define I2C_RAWISR_TXEMPTY_MASK (0x01U << I2C_RAWISR_TXEMPTY_SHIFT) +#define I2C_RAWISR_TXEMPTY(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_TXEMPTY_SHIFT)) & I2C_RAWISR_TXEMPTY_MASK) + +#define I2C_RAWISR_TXOVER_SHIFT (3) +#define I2C_RAWISR_TXOVER_MASK (0x01U << I2C_RAWISR_TXOVER_SHIFT) +#define I2C_RAWISR_TXOVER(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_TXOVER_SHIFT)) & I2C_RAWISR_TXOVER_MASK) + +#define I2C_RAWISR_RXFULL_SHIFT (2) +#define I2C_RAWISR_RXFULL_MASK (0x01U << I2C_RAWISR_RXFULL_SHIFT) +#define I2C_RAWISR_RXFULL(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_RXFULL_SHIFT)) & I2C_RAWISR_RXFULL_MASK) + +#define I2C_RAWISR_RXOVER_SHIFT (1) +#define I2C_RAWISR_RXOVER_MASK (0x01U << I2C_RAWISR_RXOVER_SHIFT) +#define I2C_RAWISR_RXOVER(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_RXOVER_SHIFT)) & I2C_RAWISR_RXOVER_MASK) + +#define I2C_RAWISR_RXUNDER_SHIFT (0) +#define I2C_RAWISR_RXUNDER_MASK (0x01U << I2C_RAWISR_RXUNDER_SHIFT) +#define I2C_RAWISR_RXUNDER(x) (((uint32_t)(((uint32_t)(x)) << I2C_RAWISR_RXUNDER_SHIFT)) & I2C_RAWISR_RXUNDER_MASK) + +/*! + * @brief I2C_RXTLR Register Bit Definition + */ + +#define I2C_RXTLR_TL_SHIFT (0) +#define I2C_RXTLR_TL_MASK (0xFFU << I2C_RXTLR_TL_SHIFT) +#define I2C_RXTLR_TL(x) (((uint32_t)(((uint32_t)(x)) << I2C_RXTLR_TL_SHIFT)) & I2C_RXTLR_TL_MASK) + +/*! + * @brief I2C_TXTLR Register Bit Definition + */ + +#define I2C_TXTLR_TL_SHIFT (0) +#define I2C_TXTLR_TL_MASK (0xFFU << I2C_TXTLR_TL_SHIFT) +#define I2C_TXTLR_TL(x) (((uint32_t)(((uint32_t)(x)) << I2C_TXTLR_TL_SHIFT)) & I2C_TXTLR_TL_MASK) + +/*! + * @brief I2C_ICR Register Bit Definition + */ + +#define I2C_ICR_ICR_SHIFT (0) +#define I2C_ICR_ICR_MASK (0x01U << I2C_ICR_ICR_SHIFT) +#define I2C_ICR_ICR(x) (((uint32_t)(((uint32_t)(x)) << I2C_ICR_ICR_SHIFT)) & I2C_ICR_ICR_MASK) + +/*! + * @brief I2C_RXUNDER Register Bit Definition + */ + +#define I2C_RXUNDER_RXUNDER_SHIFT (0) +#define I2C_RXUNDER_RXUNDER_MASK (0x01U << I2C_RXUNDER_RXUNDER_SHIFT) +#define I2C_RXUNDER_RXUNDER(x) (((uint32_t)(((uint32_t)(x)) << I2C_RXUNDER_RXUNDER_SHIFT)) & I2C_RXUNDER_RXUNDER_MASK) + +/*! + * @brief I2C_RXOVER Register Bit Definition + */ + +#define I2C_RXOVER_RXOVER_SHIFT (0) +#define I2C_RXOVER_RXOVER_MASK (0x01U << I2C_RXOVER_RXOVER_SHIFT) +#define I2C_RXOVER_RXOVER(x) (((uint32_t)(((uint32_t)(x)) << I2C_RXOVER_RXOVER_SHIFT)) & I2C_RXOVER_RXOVER_MASK) + +/*! + * @brief I2C_TXOVER Register Bit Definition + */ + +#define I2C_TXOVER_TXOVER_SHIFT (0) +#define I2C_TXOVER_TXOVER_MASK (0x01U << I2C_TXOVER_TXOVER_SHIFT) +#define I2C_TXOVER_TXOVER(x) (((uint32_t)(((uint32_t)(x)) << I2C_TXOVER_TXOVER_SHIFT)) & I2C_TXOVER_TXOVER_MASK) + +/*! + * @brief I2C_RDREQ Register Bit Definition + */ + +#define I2C_RDREQ_RDREQ_SHIFT (0) +#define I2C_RDREQ_RDREQ_MASK (0x01U << I2C_RDREQ_RDREQ_SHIFT) +#define I2C_RDREQ_RDREQ(x) (((uint32_t)(((uint32_t)(x)) << I2C_RDREQ_RDREQ_SHIFT)) & I2C_RDREQ_RDREQ_MASK) + +/*! + * @brief I2C_TXABRT Register Bit Definition + */ + +#define I2C_TXABRT_TXABRT_SHIFT (0) +#define I2C_TXABRT_TXABRT_MASK (0x01U << I2C_TXABRT_TXABRT_SHIFT) +#define I2C_TXABRT_TXABRT(x) (((uint32_t)(((uint32_t)(x)) << I2C_TXABRT_TXABRT_SHIFT)) & I2C_TXABRT_TXABRT_MASK) + +/*! + * @brief I2C_RXDONE Register Bit Definition + */ + +#define I2C_RXDONE_RXDONE_SHIFT (0) +#define I2C_RXDONE_RXDONE_MASK (0x01U << I2C_RXDONE_RXDONE_SHIFT) +#define I2C_RXDONE_RXDONE(x) (((uint32_t)(((uint32_t)(x)) << I2C_RXDONE_RXDONE_SHIFT)) & I2C_RXDONE_RXDONE_MASK) + +/*! + * @brief I2C_ACTIV Register Bit Definition + */ + +#define I2C_ACTIV_ACTIV_SHIFT (0) +#define I2C_ACTIV_ACTIV_MASK (0x01U << I2C_ACTIV_ACTIV_SHIFT) +#define I2C_ACTIV_ACTIV(x) (((uint32_t)(((uint32_t)(x)) << I2C_ACTIV_ACTIV_SHIFT)) & I2C_ACTIV_ACTIV_MASK) + +/*! + * @brief I2C_STOP Register Bit Definition + */ + +#define I2C_STOP_STOP_SHIFT (0) +#define I2C_STOP_STOP_MASK (0x01U << I2C_STOP_STOP_SHIFT) +#define I2C_STOP_STOP(x) (((uint32_t)(((uint32_t)(x)) << I2C_STOP_STOP_SHIFT)) & I2C_STOP_STOP_MASK) + +/*! + * @brief I2C_START Register Bit Definition + */ + +#define I2C_START_START_SHIFT (0) +#define I2C_START_START_MASK (0x01U << I2C_START_START_SHIFT) +#define I2C_START_START(x) (((uint32_t)(((uint32_t)(x)) << I2C_START_START_SHIFT)) & I2C_START_START_MASK) + +/*! + * @brief I2C_GC Register Bit Definition + */ + +#define I2C_GC_GC_SHIFT (0) +#define I2C_GC_GC_MASK (0x01U << I2C_GC_GC_SHIFT) +#define I2C_GC_GC(x) (((uint32_t)(((uint32_t)(x)) << I2C_GC_GC_SHIFT)) & I2C_GC_GC_MASK) + +/*! + * @brief I2C_ENR Register Bit Definition + */ + +#define I2C_ENR_ABORT_SHIFT (1) +#define I2C_ENR_ABORT_MASK (0x01U << I2C_ENR_ABORT_SHIFT) +#define I2C_ENR_ABORT(x) (((uint32_t)(((uint32_t)(x)) << I2C_ENR_ABORT_SHIFT)) & I2C_ENR_ABORT_MASK) + +#define I2C_ENR_ENABLE_SHIFT (0) +#define I2C_ENR_ENABLE_MASK (0x01U << I2C_ENR_ENABLE_SHIFT) +#define I2C_ENR_ENABLE(x) (((uint32_t)(((uint32_t)(x)) << I2C_ENR_ENABLE_SHIFT)) & I2C_ENR_ENABLE_MASK) + +/*! + * @brief I2C_SR Register Bit Definition + */ + +#define I2C_SR_SLVACTIV_SHIFT (6) +#define I2C_SR_SLVACTIV_MASK (0x01U << I2C_SR_SLVACTIV_SHIFT) +#define I2C_SR_SLVACTIV(x) (((uint32_t)(((uint32_t)(x)) << I2C_SR_SLVACTIV_SHIFT)) & I2C_SR_SLVACTIV_MASK) + +#define I2C_SR_MSTACTIV_SHIFT (5) +#define I2C_SR_MSTACTIV_MASK (0x01U << I2C_SR_MSTACTIV_SHIFT) +#define I2C_SR_MSTACTIV(x) (((uint32_t)(((uint32_t)(x)) << I2C_SR_MSTACTIV_SHIFT)) & I2C_SR_MSTACTIV_MASK) + +#define I2C_SR_RFF_SHIFT (4) +#define I2C_SR_RFF_MASK (0x01U << I2C_SR_RFF_SHIFT) +#define I2C_SR_RFF(x) (((uint32_t)(((uint32_t)(x)) << I2C_SR_RFF_SHIFT)) & I2C_SR_RFF_MASK) + +#define I2C_SR_RFNE_SHIFT (3) +#define I2C_SR_RFNE_MASK (0x01U << I2C_SR_RFNE_SHIFT) +#define I2C_SR_RFNE(x) (((uint32_t)(((uint32_t)(x)) << I2C_SR_RFNE_SHIFT)) & I2C_SR_RFNE_MASK) + +#define I2C_SR_TFE_SHIFT (2) +#define I2C_SR_TFE_MASK (0x01U << I2C_SR_TFE_SHIFT) +#define I2C_SR_TFE(x) (((uint32_t)(((uint32_t)(x)) << I2C_SR_TFE_SHIFT)) & I2C_SR_TFE_MASK) + +#define I2C_SR_TFNF_SHIFT (1) +#define I2C_SR_TFNF_MASK (0x01U << I2C_SR_TFNF_SHIFT) +#define I2C_SR_TFNF(x) (((uint32_t)(((uint32_t)(x)) << I2C_SR_TFNF_SHIFT)) & I2C_SR_TFNF_MASK) + +#define I2C_SR_ACTIV_SHIFT (0) +#define I2C_SR_ACTIV_MASK (0x01U << I2C_SR_ACTIV_SHIFT) +#define I2C_SR_ACTIV(x) (((uint32_t)(((uint32_t)(x)) << I2C_SR_ACTIV_SHIFT)) & I2C_SR_ACTIV_MASK) + +/*! + * @brief I2C_TXFLR Register Bit Definition + */ + +#define I2C_TXFLR_CNT_SHIFT (0) +#define I2C_TXFLR_CNT_MASK (0x3U << I2C_TXFLR_CNT_SHIFT) +#define I2C_TXFLR_CNT(x) (((uint32_t)(((uint32_t)(x)) << I2C_TXFLR_CNT_SHIFT)) & I2C_TXFLR_CNT_MASK) + +/*! + * @brief I2C_RXFLR Register Bit Definition + */ + +#define I2C_RXFLR_CNT_SHIFT (0) +#define I2C_RXFLR_CNT_MASK (0x3U << I2C_RXFLR_CNT_SHIFT) +#define I2C_RXFLR_CNT(x) (((uint32_t)(((uint32_t)(x)) << I2C_RXFLR_CNT_SHIFT)) & I2C_RXFLR_CNT_MASK) + +/*! + * @brief I2C_HOLD Register Bit Definition + */ + +#define I2C_HOLD_RXHOLD_SHIFT (16) +#define I2C_HOLD_RXHOLD_MASK (0xFFU << I2C_HOLD_RXHOLD_SHIFT) +#define I2C_HOLD_RXHOLD(x) (((uint32_t)(((uint32_t)(x)) << I2C_HOLD_RXHOLD_SHIFT)) & I2C_HOLD_RXHOLD_MASK) + +#define I2C_HOLD_TXHOLD_SHIFT (0) +#define I2C_HOLD_TXHOLD_MASK (0xFFFFU << I2C_HOLD_TXHOLD_SHIFT) +#define I2C_HOLD_TXHOLD(x) (((uint32_t)(((uint32_t)(x)) << I2C_HOLD_TXHOLD_SHIFT)) & I2C_HOLD_TXHOLD_MASK) + +/*! + * @brief I2C_DMA Register Bit Definition + */ + +#define I2C_DMA_TXEN_SHIFT (1) +#define I2C_DMA_TXEN_MASK (0x01U << I2C_DMA_TXEN_SHIFT) +#define I2C_DMA_TXEN(x) (((uint32_t)(((uint32_t)(x)) << I2C_DMA_TXEN_SHIFT)) & I2C_DMA_TXEN_MASK) + +#define I2C_DMA_RXEN_SHIFT (0) +#define I2C_DMA_RXEN_MASK (0x01U << I2C_DMA_RXEN_SHIFT) +#define I2C_DMA_RXEN(x) (((uint32_t)(((uint32_t)(x)) << I2C_DMA_RXEN_SHIFT)) & I2C_DMA_RXEN_MASK) + +/*! + * @brief I2C_SETUP Register Bit Definition + */ + +#define I2C_SETUP_CNT_SHIFT (0) +#define I2C_SETUP_CNT_MASK (0xFFU << I2C_SETUP_CNT_SHIFT) +#define I2C_SETUP_CNT(x) (((uint32_t)(((uint32_t)(x)) << I2C_SETUP_CNT_SHIFT)) & I2C_SETUP_CNT_MASK) + +/*! + * @brief I2C_GCR Register Bit Definition + */ + +#define I2C_GCR_GC_SHIFT (0) +#define I2C_GCR_GC_MASK (0x01U << I2C_GCR_GC_SHIFT) +#define I2C_GCR_GC(x) (((uint32_t)(((uint32_t)(x)) << I2C_GCR_GC_SHIFT)) & I2C_GCR_GC_MASK) + +/*! + * @brief I2C_SLVMASK Register Bit Definition + */ + +#define I2C_SLVMASK_MASK_SHIFT (0) +#define I2C_SLVMASK_MASK_MASK (0x3FFU << I2C_SLVMASK_MASK_SHIFT) +#define I2C_SLVMASK_MASK(x) (((uint32_t)(((uint32_t)(x)) << I2C_SLVMASK_MASK_SHIFT)) & I2C_SLVMASK_MASK_MASK) + +/*! + * @brief I2C_SLVRCVADDR Register Bit Definition + */ + +#define I2C_SLVRCVADDR_ADDR_SHIFT (0) +#define I2C_SLVRCVADDR_ADDR_MASK (0x3FFU << I2C_SLVRCVADDR_ADDR_SHIFT) +#define I2C_SLVRCVADDR_ADDR(x) (((uint32_t)(((uint32_t)(x)) << I2C_SLVRCVADDR_ADDR_SHIFT)) & I2C_SLVRCVADDR_ADDR_MASK) + +/*! + * @} + */ /* end of group I2C_Register_Masks */ +/****************************************************************************** + * I2C Instance +******************************************************************************/ +#define I2C1 ((I2C_Type*)I2C1_BASE) +#define I2C2 ((I2C_Type*)I2C2_BASE) + +/*! + * @} + */ /* end of group I2C_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup CAN_Peripheral_Access_Layer CAN Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * CAN Basic Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR; ///< CAN control register offset: 0x00 + __IO uint32_t CMR; ///< CAN command register offset: 0x04 + __IO uint32_t SR; ///< CAN status register offset: 0x08 + __IO uint32_t IR; ///< CAN Interrupt Register offset: 0x0C + __IO uint32_t GROUP0ACR; ///< CAN Acceptance Code Register Group 0 offset: 0x10 + __IO uint32_t GROUP0AMR; ///< CAN acceptance mask register group 0 offset: 0x14 + __IO uint32_t BTR0; ///< CAN bus timing 0 offset: 0x18 + __IO uint32_t BTR1; ///< CAN bus timing 1 offset: 0x1C + __IO uint32_t Reserved19[2]; ///< Reserved + __IO uint32_t TXID0; ///< CAN send identification code register 0 offset: 0x28 + __IO uint32_t TXID1; ///< CAN send identification code register 1 offset: 0x2C + __IO uint32_t Reserved20[20]; ///< Reserved + __IO uint32_t CDR; ///< CAN clock divider register offset: 0x7C + __IO uint32_t AFM0; ///< CAN filter mode register 0 offset: 0x80 + __IO uint32_t AFM1; ///< CAN filter mode register 1 offset: 0x84 + __IO uint32_t AFM2; ///< CAN filter mode register 2 offset: 0x88 + __IO uint32_t FGA0; ///< CAN filter group enable register 0 offset: 0x8c + __IO uint32_t FGA1; ///< CAN filter group enable register 1 offset: 0x90 + __IO uint32_t FGA2; ///< CAN filter group enable register 2 offset: 0x94 + __IO uint32_t GROUPACR; ///< CAN Acceptance Code Register Group x(X = 1~19)offset: 0x98 + __IO uint32_t Reserved21[3]; ///< Reserved + __IO uint32_t GROUPAMR; ///< CAN Acceptance Mask Register Group x(X = 1~19)offset: 0xA8 +} CAN_Basic_Type; +/******************************************************************************* + * CAN Peli Type + ******************************************************************************/ +typedef struct { + __IO uint32_t MOD; ///< CAN mode register offset: 0x00 + __IO uint32_t CMR; ///< CAN command register offset: 0x04 + __IO uint32_t SR; ///< CAN status register offset: 0x08 + __IO uint32_t Reserved19a[1]; ///< Reserved + __IO uint32_t IER; ///< CAN interrupt enable register offset: 0x10 + __IO uint32_t Reserved20a[1]; ///< Reserved + __IO uint32_t BTR0; ///< CAN bus timing 0 offset: 0x18 + __IO uint32_t BTR1; ///< CAN bus timing 1 offset: 0x1C + __IO uint32_t Reserved21a[3]; ///< Reserved + __IO uint32_t ALC; ///< CAN Arbitration Loss Capture Register offset: 0x2C + __IO uint32_t ECC; ///< CAN error code capture offset: 0x30 + __IO uint32_t EWLR; ///< CAN error alarm limit register offset: 0x34 + __IO uint32_t RXERR; ///< CAN RX error count register offset: 0x38 + __IO uint32_t TXERR; ///< CAN TX error count register offset: 0x3C + __IO uint32_t SFF; ///< Send frame information register offset: 0x40 + __IO uint32_t TXID0; ///< CAN send identification code register 0 offset: 0x44 + __IO uint32_t TXID1; ///< CAN send identification code register 1 offset: 0x48 + __IO uint32_t TXDATA0; ///< CAN send data register 0 offset: 0x4C + __IO uint32_t TXDATA1; ///< CAN send data register 1 offset: 0x50 + __IO uint32_t Reserved20[10]; ///< Reserved + __IO uint32_t CDR; ///< CAN clock divider register offset: 0x7C + __IO uint32_t AFM0; ///< CAN filter mode register 0 offset: 0x80 + __IO uint32_t AFM1; ///< CAN filter mode register 1 offset: 0x84 + __IO uint32_t AFM2; ///< CAN filter mode register 2 offset: 0x88 + __IO uint32_t FGA0; ///< CAN filter group enable register 0 offset: 0x8c + __IO uint32_t FGA1; ///< CAN filter group enable register 1 offset: 0x90 + __IO uint32_t FGA2; ///< CAN filter group enable register 2 offset: 0x94 + __IO uint32_t GROUPACR; ///< CAN Acceptance Code Register Group x(X = 1~19)offset: 0x98 + __IO uint32_t Reserved21[3]; ///< Reserved + __IO uint32_t GROUPAMR; ///< CAN Acceptance Mask Register Group x(X = 1~19)offset: 0xA8 +} CAN_Peli_Type; + +/******************************************************************************* + * CAN Type + ******************************************************************************/ + +/*! + * @addtogroup CAN_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief CAN_MOD Register Bit Definition + */ + +#define CAN_MOD_AFM_SHIFT (3) +#define CAN_MOD_AFM_MASK (0x01U << CAN_MOD_AFM_SHIFT) +#define CAN_MOD_AFM(x) (((uint32_t)(((uint32_t)(x)) << CAN_MOD_AFM_SHIFT)) & CAN_MOD_AFM_MASK) + +#define CAN_MOD_STM_SHIFT (2) +#define CAN_MOD_STM_MASK (0x01U << CAN_MOD_STM_SHIFT) +#define CAN_MOD_STM(x) (((uint32_t)(((uint32_t)(x)) << CAN_MOD_STM_SHIFT)) & CAN_MOD_STM_MASK) + +#define CAN_MOD_LOM_SHIFT (1) +#define CAN_MOD_LOM_MASK (0x01U << CAN_MOD_LOM_SHIFT) +#define CAN_MOD_LOM(x) (((uint32_t)(((uint32_t)(x)) << CAN_MOD_LOM_SHIFT)) & CAN_MOD_LOM_MASK) + +#define CAN_MOD_RM_SHIFT (0) +#define CAN_MOD_RM_MASK (0x01U << CAN_MOD_RM_SHIFT) +#define CAN_MOD_RM(x) (((uint32_t)(((uint32_t)(x)) << CAN_MOD_RM_SHIFT)) & CAN_MOD_RM_MASK) + +/*! + * @brief CAN_CR Register Bit Definition + */ + +#define CAN_CR_OIE_SHIFT (4) +#define CAN_CR_OIE_MASK (0x01U << CAN_CR_OIE_SHIFT) +#define CAN_CR_OIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_CR_OIE_SHIFT)) & CAN_CR_OIE_MASK) + +#define CAN_CR_EIE_SHIFT (3) +#define CAN_CR_EIE_MASK (0x01U << CAN_CR_EIE_SHIFT) +#define CAN_CR_EIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_CR_EIE_SHIFT)) & CAN_CR_EIE_MASK) + +#define CAN_CR_TIE_SHIFT (2) +#define CAN_CR_TIE_MASK (0x01U << CAN_CR_TIE_SHIFT) +#define CAN_CR_TIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_CR_TIE_SHIFT)) & CAN_CR_TIE_MASK) + +#define CAN_CR_RIE_SHIFT (1) +#define CAN_CR_RIE_MASK (0x01U << CAN_CR_RIE_SHIFT) +#define CAN_CR_RIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_CR_RIE_SHIFT)) & CAN_CR_RIE_MASK) + +#define CAN_CR_RR_SHIFT (0) +#define CAN_CR_RR_MASK (0x01U << CAN_CR_RR_SHIFT) +#define CAN_CR_RR(x) (((uint32_t)(((uint32_t)(x)) << CAN_CR_RR_SHIFT)) & CAN_CR_RR_MASK) + +/*! + * @brief CAN_CMR Register Bit Definition + */ + +#define CAN_CMR_ERB_SHIFT (5) +#define CAN_CMR_ERB_MASK (0x01U << CAN_CMR_ERB_SHIFT) +#define CAN_CMR_ERB(x) (((uint32_t)(((uint32_t)(x)) << CAN_CMR_ERB_SHIFT)) & CAN_CMR_ERB_MASK) + +#define CAN_CMR_SRR_SHIFT (4) +#define CAN_CMR_SRR_MASK (0x01U << CAN_CMR_SRR_SHIFT) +#define CAN_CMR_SRR(x) (((uint32_t)(((uint32_t)(x)) << CAN_CMR_SRR_SHIFT)) & CAN_CMR_SRR_MASK) + +#define CAN_CMR_CDO_SHIFT (3) +#define CAN_CMR_CDO_MASK (0x01U << CAN_CMR_CDO_SHIFT) +#define CAN_CMR_CDO(x) (((uint32_t)(((uint32_t)(x)) << CAN_CMR_CDO_SHIFT)) & CAN_CMR_CDO_MASK) + +#define CAN_CMR_RRB_SHIFT (2) +#define CAN_CMR_RRB_MASK (0x01U << CAN_CMR_RRB_SHIFT) +#define CAN_CMR_RRB(x) (((uint32_t)(((uint32_t)(x)) << CAN_CMR_RRB_SHIFT)) & CAN_CMR_RRB_MASK) + +#define CAN_CMR_AT_SHIFT (1) +#define CAN_CMR_AT_MASK (0x01U << CAN_CMR_AT_SHIFT) +#define CAN_CMR_AT(x) (((uint32_t)(((uint32_t)(x)) << CAN_CMR_AT_SHIFT)) & CAN_CMR_AT_MASK) + +#define CAN_CMR_TR_SHIFT (0) +#define CAN_CMR_TR_MASK (0x01U << CAN_CMR_TR_SHIFT) +#define CAN_CMR_TR(x) (((uint32_t)(((uint32_t)(x)) << CAN_CMR_TR_SHIFT)) & CAN_CMR_TR_MASK) + +/*! + * @brief CAN_SR Register Bit Definition + */ + +#define CAN_SR_BS_SHIFT (7) +#define CAN_SR_BS_MASK (0x01U << CAN_SR_BS_SHIFT) +#define CAN_SR_BS(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_BS_SHIFT)) & CAN_SR_BS_MASK) + +#define CAN_SR_ES_SHIFT (6) +#define CAN_SR_ES_MASK (0x01U << CAN_SR_ES_SHIFT) +#define CAN_SR_ES(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_ES_SHIFT)) & CAN_SR_ES_MASK) + +#define CAN_SR_TS_SHIFT (5) +#define CAN_SR_TS_MASK (0x01U << CAN_SR_TS_SHIFT) +#define CAN_SR_TS(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_TS_SHIFT)) & CAN_SR_TS_MASK) + +#define CAN_SR_RS_SHIFT (4) +#define CAN_SR_RS_MASK (0x01U << CAN_SR_RS_SHIFT) +#define CAN_SR_RS(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_RS_SHIFT)) & CAN_SR_RS_MASK) + +#define CAN_SR_TCS_SHIFT (3) +#define CAN_SR_TCS_MASK (0x01U << CAN_SR_TCS_SHIFT) +#define CAN_SR_TCS(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_TCS_SHIFT)) & CAN_SR_TCS_MASK) + +#define CAN_SR_TBS_SHIFT (2) +#define CAN_SR_TBS_MASK (0x01U << CAN_SR_TBS_SHIFT) +#define CAN_SR_TBS(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_TBS_SHIFT)) & CAN_SR_TBS_MASK) + +#define CAN_SR_DOS_SHIFT (1) +#define CAN_SR_DOS_MASK (0x01U << CAN_SR_DOS_SHIFT) +#define CAN_SR_DOS(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_DOS_SHIFT)) & CAN_SR_DOS_MASK) + +#define CAN_SR_RBS_SHIFT (0) +#define CAN_SR_RBS_MASK (0x01U << CAN_SR_RBS_SHIFT) +#define CAN_SR_RBS(x) (((uint32_t)(((uint32_t)(x)) << CAN_SR_RBS_SHIFT)) & CAN_SR_RBS_MASK) + +/*! + * @brief +CAN_IR Register Bit Definition + */ + +#define CAN_IR_BEI_SHIFT (7) +#define CAN_IR_BEI_MASK (0x01U << CAN_IR_BEI_SHIFT) +#define CAN_IR_BEI(x) (((uint32_t)(((uint32_t)(x)) << CAN_IR_BEI_SHIFT)) & CAN_IR_BEI_MASK) + +#define CAN_IR_ALI_SHIFT (6) +#define CAN_IR_ALI_MASK (0x01U << CAN_IR_ALI_SHIFT) +#define CAN_IR_ALI(x) (((uint32_t)(((uint32_t)(x)) << CAN_IR_ALI_SHIFT)) & CAN_IR_ALI_MASK) + +#define CAN_IR_EPI_SHIFT (5) +#define CAN_IR_EPI_MASK (0x01U << CAN_IR_EPI_SHIFT) +#define CAN_IR_EPI(x) (((uint32_t)(((uint32_t)(x)) << CAN_IR_EPI_SHIFT)) & CAN_IR_EPI_MASK) + +#define CAN_IR_DOI_SHIFT (3) +#define CAN_IR_DOI_MASK (0x01U << CAN_IR_DOI_SHIFT) +#define CAN_IR_DOI(x) (((uint32_t)(((uint32_t)(x)) << CAN_IR_DOI_SHIFT)) & CAN_IR_DOI_MASK) + +#define CAN_IR_EI_SHIFT (2) +#define CAN_IR_EI_MASK (0x01U << CAN_IR_EI_SHIFT) +#define CAN_IR_EI(x) (((uint32_t)(((uint32_t)(x)) << CAN_IR_EI_SHIFT)) & CAN_IR_EI_MASK) + +#define CAN_IR_TI_SHIFT (1) +#define CAN_IR_TI_MASK (0x01U << CAN_IR_TI_SHIFT) +#define CAN_IR_TI(x) (((uint32_t)(((uint32_t)(x)) << CAN_IR_TI_SHIFT)) & CAN_IR_TI_MASK) + +#define CAN_IR_RI_SHIFT (0) +#define CAN_IR_RI_MASK (0x01U << CAN_IR_RI_SHIFT) +#define CAN_IR_RI(x) (((uint32_t)(((uint32_t)(x)) << CAN_IR_RI_SHIFT)) & CAN_IR_RI_MASK) + +/*! + * @brief CAN_IER Register Bit Definition + */ + +#define CAN_IER_BEIE_SHIFT (7) +#define CAN_IER_BEIE_MASK (0x01U << CAN_IER_BEIE_SHIFT) +#define CAN_IER_BEIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_IER_BEIE_SHIFT)) & CAN_IER_BEIE_MASK) + +#define CAN_IER_ALIE_SHIFT (6) +#define CAN_IER_ALIE_MASK (0x01U << CAN_IER_ALIE_SHIFT) +#define CAN_IER_ALIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_IER_ALIE_SHIFT)) & CAN_IER_ALIE_MASK) + +#define CAN_IER_EPIE_SHIFT (5) +#define CAN_IER_EPIE_MASK (0x01U << CAN_IER_EPIE_SHIFT) +#define CAN_IER_EPIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_IER_EPIE_SHIFT)) & CAN_IER_EPIE_MASK) + +#define CAN_IER_DOIE_SHIFT (3) +#define CAN_IER_DOIE_MASK (0x01U << CAN_IER_DOIE_SHIFT) +#define CAN_IER_DOIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_IER_DOIE_SHIFT)) & CAN_IER_DOIE_MASK) + +#define CAN_IER_EIE_SHIFT (2) +#define CAN_IER_EIE_MASK (0x01U << CAN_IER_EIE_SHIFT) +#define CAN_IER_EIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_IER_EIE_SHIFT)) & CAN_IER_EIE_MASK) + +#define CAN_IER_TIE_SHIFT (1) +#define CAN_IER_TIE_MASK (0x01U << CAN_IER_TIE_SHIFT) +#define CAN_IER_TIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_IER_TIE_SHIFT)) & CAN_IER_TIE_MASK) + +#define CAN_IER_RIE_SHIFT (0) +#define CAN_IER_RIE_MASK (0x01U << CAN_IER_RIE_SHIFT) +#define CAN_IER_RIE(x) (((uint32_t)(((uint32_t)(x)) << CAN_IER_RIE_SHIFT)) & CAN_IER_RIE_MASK) + +/*! + * @brief CAN_GROUP0ACR Register Bit Definition + */ + +#define CAN_GROUP0ACR_AC_SHIFT (0) +#define CAN_GROUP0ACR_AC_MASK (0xFFU << CAN_GROUP0ACR_AC_SHIFT) +#define CAN_GROUP0ACR_AC(x) (((uint32_t)(((uint32_t)(x)) << CAN_GROUP0ACR_AC_SHIFT)) & CAN_GROUP0ACR_AC_MASK) + +/*! + * @brief CAN_GROUP0AMR Register Bit Definition + */ + +#define CAN_GROUP0AMR_AM_SHIFT (0) +#define CAN_GROUP0AMR_AM_MASK (0xFFU << CAN_GROUP0AMR_AM_SHIFT) +#define CAN_GROUP0AMR_AM(x) (((uint32_t)(((uint32_t)(x)) << CAN_GROUP0AMR_AM_SHIFT)) & CAN_GROUP0AMR_AM_MASK) + +/*! + * @brief CAN_BTR0 Register Bit Definition + */ + +#define CAN_BTR0_SJW_SHIFT (6) +#define CAN_BTR0_SJW_MASK (0x3U << CAN_BTR0_SJW_SHIFT) +#define CAN_BTR0_SJW(x) (((uint32_t)(((uint32_t)(x)) << CAN_BTR0_SJW_SHIFT)) & CAN_BTR0_SJW_MASK) + +#define CAN_BTR0_BRP_SHIFT (0) +#define CAN_BTR0_BRP_MASK (0x3FU << CAN_BTR0_BRP_SHIFT) +#define CAN_BTR0_BRP(x) (((uint32_t)(((uint32_t)(x)) << CAN_BTR0_BRP_SHIFT)) & CAN_BTR0_BRP_MASK) + +/*! + * @brief CAN_BTR1 Register Bit Definition + */ + +#define CAN_BTR1_SAM_SHIFT (7) +#define CAN_BTR1_SAM_MASK (0x01U << CAN_BTR1_SAM_SHIFT) +#define CAN_BTR1_SAM(x) (((uint32_t)(((uint32_t)(x)) << CAN_BTR1_SAM_SHIFT)) & CAN_BTR1_SAM_MASK) + +#define CAN_BTR1_TSEG2TSEG1_SHIFT (0) +#define CAN_BTR1_TSEG2TSEG1_MASK (0x7FU << CAN_BTR1_TSEG2TSEG1_SHIFT) +#define CAN_BTR1_TSEG2TSEG1(x) (((uint32_t)(((uint32_t)(x)) << CAN_BTR1_TSEG2TSEG1_SHIFT)) & CAN_BTR1_TSEG2TSEG1_MASK) + +/*! + * @brief CAN_TXID0 Register Bit Definition + */ + +#define CAN_TXID0_IDX_SHIFT (0) +#define CAN_TXID0_IDX_MASK (0xFFU << CAN_TXID0_IDX_SHIFT) +#define CAN_TXID0_IDX(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXID0_IDX_SHIFT)) & CAN_TXID0_IDX_MASK) + +/*! + * @brief CAN_TXID1 Register Bit Definition + */ + +#define CAN_TXID1_IDX_SHIFT (5) +#define CAN_TXID1_IDX_MASK (0x7U << CAN_TXID1_IDX_SHIFT) +#define CAN_TXID1_IDX(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXID1_IDX_SHIFT)) & CAN_TXID1_IDX_MASK) + +#define CAN_TXID1_RTR_SHIFT (4) +#define CAN_TXID1_RTR_MASK (0x01U << CAN_TXID1_RTR_SHIFT) +#define CAN_TXID1_RTR(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXID1_RTR_SHIFT)) & CAN_TXID1_RTR_MASK) + +#define CAN_TXID1_DLCX_SHIFT (0) +#define CAN_TXID1_DLCX_MASK (0xFU << CAN_TXID1_DLCX_SHIFT) +#define CAN_TXID1_DLCX(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXID1_DLCX_SHIFT)) & CAN_TXID1_DLCX_MASK) + +/*! + * @brief CAN_ALC Register Bit Definition + */ + +#define CAN_ALC_BITNO_SHIFT (0) +#define CAN_ALC_BITNO_MASK (0x1FU << CAN_ALC_BITNO_SHIFT) +#define CAN_ALC_BITNO(x) (((uint32_t)(((uint32_t)(x)) << CAN_ALC_BITNO_SHIFT)) & CAN_ALC_BITNO_MASK) + +/*! + * @brief CAN_ECC Register Bit Definition + */ + +#define CAN_ECC_ERRC_SHIFT (6) +#define CAN_ECC_ERRC_MASK (0x3U << CAN_ECC_ERRC_SHIFT) +#define CAN_ECC_ERRC(x) (((uint32_t)(((uint32_t)(x)) << CAN_ECC_ERRC_SHIFT)) & CAN_ECC_ERRC_MASK) + +#define CAN_ECC_DIR_SHIFT (5) +#define CAN_ECC_DIR_MASK (0x01U << CAN_ECC_DIR_SHIFT) +#define CAN_ECC_DIR(x) (((uint32_t)(((uint32_t)(x)) << CAN_ECC_DIR_SHIFT)) & CAN_ECC_DIR_MASK) + +#define CAN_ECC_SEG_SHIFT (0) +#define CAN_ECC_SEG_MASK (0x1FU << CAN_ECC_SEG_SHIFT) +#define CAN_ECC_SEG(x) (((uint32_t)(((uint32_t)(x)) << CAN_ECC_SEG_SHIFT)) & CAN_ECC_SEG_MASK) + +/*! + * @brief CAN_EWLR Register Bit Definition + */ + +#define CAN_EWLR_EWL_SHIFT (0) +#define CAN_EWLR_EWL_MASK (0xFFU << CAN_EWLR_EWL_SHIFT) +#define CAN_EWLR_EWL(x) (((uint32_t)(((uint32_t)(x)) << CAN_EWLR_EWL_SHIFT)) & CAN_EWLR_EWL_MASK) + +/*! + * @brief CAN_RXERR Register Bit Definition + */ + +#define CAN_RXERR_RXERR_SHIFT (0) +#define CAN_RXERR_RXERR_MASK (0xFFU << CAN_RXERR_RXERR_SHIFT) +#define CAN_RXERR_RXERR(x) (((uint32_t)(((uint32_t)(x)) << CAN_RXERR_RXERR_SHIFT)) & CAN_RXERR_RXERR_MASK) + +/*! + * @brief CAN_TXERR Register Bit Definition + */ + +#define CAN_TXERR_TXERR_SHIFT (0) +#define CAN_TXERR_TXERR_MASK (0xFFU << CAN_TXERR_TXERR_SHIFT) +#define CAN_TXERR_TXERR(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXERR_TXERR_SHIFT)) & CAN_TXERR_TXERR_MASK) + +#define CAN_TXERR_RTR_SHIFT (6) +#define CAN_TXERR_RTR_MASK (0x01U << CAN_TXERR_RTR_SHIFT) +#define CAN_TXERR_RTR(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXERR_RTR_SHIFT)) & CAN_TXERR_RTR_MASK) + +#define CAN_TXERR_DLC_SHIFT (0) +#define CAN_TXERR_DLC_MASK (0xFU << CAN_TXERR_DLC_SHIFT) +#define CAN_TXERR_DLC(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXERR_DLC_SHIFT)) & CAN_TXERR_DLC_MASK) + +/*! + * @brief CAN_SFF Register Bit Definition + */ + +#define CAN_SFF_FF_SHIFT (7) +#define CAN_SFF_FF_MASK (0x01U << CAN_SFF_FF_SHIFT) +#define CAN_SFF_FF(x) (((uint32_t)(((uint32_t)(x)) << CAN_SFF_FF_SHIFT)) & CAN_SFF_FF_MASK) + +#define CAN_SFF_RTR_SHIFT (6) +#define CAN_SFF_RTR_MASK (0x01U << CAN_SFF_RTR_SHIFT) +#define CAN_SFF_RTR(x) (((uint32_t)(((uint32_t)(x)) << CAN_SFF_RTR_SHIFT)) & CAN_SFF_RTR_MASK) + +#define CAN_SFF_DLC_SHIFT (0) +#define CAN_SFF_DLC_MASK (0xFU << CAN_SFF_DLC_SHIFT) +#define CAN_SFF_DLC(x) (((uint32_t)(((uint32_t)(x)) << CAN_SFF_DLC_SHIFT)) & CAN_SFF_DLC_MASK) + +/*! + * @brief CAN_TXID0 Register Bit Definition + */ + +#define CAN_TXID0_IDX_SHIFT (0) +#define CAN_TXID0_IDX_MASK (0xFFU << CAN_TXID0_IDX_SHIFT) +#define CAN_TXID0_IDX(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXID0_IDX_SHIFT)) & CAN_TXID0_IDX_MASK) + +/*! + * @brief CAN_TXID1 Register Bit Definition + */ + +#define CAN_TXID1_ID_SHIFT (0) +#define CAN_TXID1_ID_MASK (0xFFU << CAN_TXID1_ID_SHIFT) +#define CAN_TXID1_ID(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXID1_ID_SHIFT)) & CAN_TXID1_ID_MASK) + +/*! + * @brief CAN_TXDATA0 Register Bit Definition + */ + +#define CAN_TXDATA0_DATA0_SHIFT (0) +#define CAN_TXDATA0_DATA0_MASK (0xFFU << CAN_TXDATA0_DATA0_SHIFT) +#define CAN_TXDATA0_DATA0(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXDATA0_DATA0_SHIFT)) & CAN_TXDATA0_DATA0_MASK) + +/*! + * @brief CAN_TXDATA1 Register Bit Definition + */ + +#define CAN_TXDATA1_DATA1_SHIFT (0) +#define CAN_TXDATA1_DATA1_MASK (0xFFU << CAN_TXDATA1_DATA1_SHIFT) +#define CAN_TXDATA1_DATA1(x) (((uint32_t)(((uint32_t)(x)) << CAN_TXDATA1_DATA1_SHIFT)) & CAN_TXDATA1_DATA1_MASK) + +/*! + * @brief CAN_CDR Register Bit Definition + */ + +#define CAN_CDR_MODE_SHIFT (7) +#define CAN_CDR_MODE_MASK (0x01U << CAN_CDR_MODE_SHIFT) +#define CAN_CDR_MODE(x) (((uint32_t)(((uint32_t)(x)) << CAN_CDR_MODE_SHIFT)) & CAN_CDR_MODE_MASK) + +/*! + * @brief CAN_AFM0 Register Bit Definition + */ + +#define CAN_AFM0_AFMX_SHIFT (1) +#define CAN_AFM0_AFMX_MASK (0x7FU << CAN_AFM0_AFMX_SHIFT) +#define CAN_AFM0_AFMX(x) (((uint32_t)(((uint32_t)(x)) << CAN_AFM0_AFMX_SHIFT)) & CAN_AFM0_AFMX_MASK) + +/*! + * @brief CAN_AFM1 Register Bit Definition + */ + +#define CAN_AFM1_AFMX_SHIFT (0) +#define CAN_AFM1_AFMX_MASK (0xFFU << CAN_AFM1_AFMX_SHIFT) +#define CAN_AFM1_AFMX(x) (((uint32_t)(((uint32_t)(x)) << CAN_AFM1_AFMX_SHIFT)) & CAN_AFM1_AFMX_MASK) + +/*! + * @brief CAN_AFM2 Register Bit Definition + */ + +#define CAN_AFM2_AFMX_SHIFT (0) +#define CAN_AFM2_AFMX_MASK (0xFU << CAN_AFM2_AFMX_SHIFT) +#define CAN_AFM2_AFMX(x) (((uint32_t)(((uint32_t)(x)) << CAN_AFM2_AFMX_SHIFT)) & CAN_AFM2_AFMX_MASK) + +/*! + * @brief CAN_FGA0 Register Bit Definition + */ + +#define CAN_FGA0_FGAX_SHIFT (1) +#define CAN_FGA0_FGAX_MASK (0x7FU << CAN_FGA0_FGAX_SHIFT) +#define CAN_FGA0_FGAX(x) (((uint32_t)(((uint32_t)(x)) << CAN_FGA0_FGAX_SHIFT)) & CAN_FGA0_FGAX_MASK) + +/*! + * @brief CAN_FGA1 Register Bit Definition + */ + +#define CAN_FGA1_FGAX_SHIFT (0) +#define CAN_FGA1_FGAX_MASK (0xFFU << CAN_FGA1_FGAX_SHIFT) +#define CAN_FGA1_FGAX(x) (((uint32_t)(((uint32_t)(x)) << CAN_FGA1_FGAX_SHIFT)) & CAN_FGA1_FGAX_MASK) + +/*! + * @brief CAN_FGA2 Register Bit Definition + */ + +#define CAN_FGA2_FGAX_SHIFT (0) +#define CAN_FGA2_FGAX_MASK (0xFFU << CAN_FGA2_FGAX_SHIFT) +#define CAN_FGA2_FGAX(x) (((uint32_t)(((uint32_t)(x)) << CAN_FGA2_FGAX_SHIFT)) & CAN_FGA2_FGAX_MASK) + +/*! + * @brief CAN_GROUPACR + Register Bit Definition + */ + +#define CAN_GROUPACR_AC_SHIFT (0) +#define CAN_GROUPACR_AC_MASK (0xFFU << CAN_GROUPACR_AC_SHIFT) +#define CAN_GROUPACR_AC(x) (((uint32_t)(((uint32_t)(x)) << CAN_GROUPACR_AC_SHIFT)) & CAN_GROUPACR_AC_MASK) + +/*! + * @brief CAN_GROUPAMR + Register Bit Definition + */ + +#define CAN_GROUPAMR_AM_SHIFT (0) +#define CAN_GROUPAMR_AM_MASK (0xFFU << CAN_GROUPAMR_AM_SHIFT) +#define CAN_GROUPAMR_AM(x) (((uint32_t)(((uint32_t)(x)) << CAN_GROUPAMR_AM_SHIFT)) & CAN_GROUPAMR_AM_MASK) + +/*! + * @} + */ /* end of group CAN_Register_Masks */ +/****************************************************************************** + * CAN Instance +******************************************************************************/ +#define CAN_Basic ((CAN_Basic_Type*)CAN_BASE) +#define CAN_Peli ((CAN_Peli_Type*)CAN_BASE) + +/*! + * @} + */ /* end of group CAN_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup USB_Peripheral_Access_Layer USB Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * USB Type + ******************************************************************************/ +typedef struct { + __IO uint32_t Reserved22[4]; ///< Reserved + __IO uint32_t OTGISTAT; ///< OTG Interrupt Status Register offset: 0x10 + __IO uint32_t OTGICTRL; ///< OTG Interrupt Control Register offset: 0x14 + __IO uint32_t OTGSTAT; ///< OTG Status Register offset: 0x18 + __IO uint32_t OTGCTRL; ///< OTG Control register offset: 0x1C + __IO uint32_t Reserved23[24]; ///< Reserved + __IO uint32_t INTSTAT; ///< Interrupt status register offset: 0x80 + __IO uint32_t INTENB; ///< Interrupt enable register offset: 0x84 + __IO uint32_t ERRSTAT; ///< Error interrupt status register offset: 0x88 + __IO uint32_t ERRENB; ///< Error interrupt enable register offset: 0x8C + __IO uint32_t STAT; ///< Status register offset: 0x90 + __IO uint32_t CTL; ///< Control register offset: 0x94 + __IO uint32_t ADDR; ///< Address register offset: 0x98 + __IO uint32_t BDTPAGE01; ///< BDT page register 1 offset: 0x9C + __IO uint32_t FRMNUML; ///< Frame number register offset: 0xA0 + __IO uint32_t FRMNUMH; ///< Frame number register offset: 0xA4 + __IO uint32_t TOKEN; ///< Token register offset: 0xA8 + __IO uint32_t SOFTHLD; ///< SOF threshold register offset: 0xAC + __IO uint32_t BDTPAGE02; ///< BDT page register 2 offset: 0xB0 + __IO uint32_t BDTPAGE03; ///< BDT page register 3 offset: 0xB4 + __IO uint32_t Reserved24[2]; ///< Reserved + __IO uint32_t EPCTL[16]; ///< Endpoint control register offset: 0xC0 +} USB_Type; + +/******************************************************************************* + * USB Type + ******************************************************************************/ + +/*! + * @addtogroup USB_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief USB_OTGISTAT Register Bit Definition + */ + +#define USB_OTGISTAT_IDCHG_SHIFT (7) +#define USB_OTGISTAT_IDCHG_MASK (0x01U << USB_OTGISTAT_IDCHG_SHIFT) +#define USB_OTGISTAT_IDCHG(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGISTAT_IDCHG_SHIFT)) & USB_OTGISTAT_IDCHG_MASK) + +#define USB_OTGISTAT_1MSEC_SHIFT (6) +#define USB_OTGISTAT_1MSEC_MASK (0x01U << USB_OTGISTAT_1MSEC_SHIFT) +#define USB_OTGISTAT_1MSEC(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGISTAT_1MSEC_SHIFT)) & USB_OTGISTAT_1MSEC_MASK) + +#define USB_OTGISTAT_LINESTATECHG_SHIFT (5) +#define USB_OTGISTAT_LINESTATECHG_MASK (0x01U << USB_OTGISTAT_LINESTATECHG_SHIFT) +#define USB_OTGISTAT_LINESTATECHG(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGISTAT_LINESTATECHG_SHIFT)) & USB_OTGISTAT_LINESTATECHG_MASK) + +#define USB_OTGISTAT_SESSVLDCHG_SHIFT (2) +#define USB_OTGISTAT_SESSVLDCHG_MASK (0x01U << USB_OTGISTAT_SESSVLDCHG_SHIFT) +#define USB_OTGISTAT_SESSVLDCHG(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGISTAT_SESSVLDCHG_SHIFT)) & USB_OTGISTAT_SESSVLDCHG_MASK) + +#define USB_OTGISTAT_BSESSENDCHG_SHIFT (2) +#define USB_OTGISTAT_BSESSENDCHG_MASK (0x01U << USB_OTGISTAT_BSESSENDCHG_SHIFT) +#define USB_OTGISTAT_BSESSENDCHG(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGISTAT_BSESSENDCHG_SHIFT)) & USB_OTGISTAT_BSESSENDCHG_MASK) + +#define USB_OTGISTAT_AVBUSVLDCHG_SHIFT (0) +#define USB_OTGISTAT_AVBUSVLDCHG_MASK (0x01U << USB_OTGISTAT_AVBUSVLDCHG_SHIFT) +#define USB_OTGISTAT_AVBUSVLDCHG(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGISTAT_AVBUSVLDCHG_SHIFT)) & USB_OTGISTAT_AVBUSVLDCHG_MASK) + +/*! + * @brief USB_OTGICTRL Register Bit Definition + */ + +#define USB_OTGICTRL_IDEN_SHIFT (7) +#define USB_OTGICTRL_IDEN_MASK (0x01U << USB_OTGICTRL_IDEN_SHIFT) +#define USB_OTGICTRL_IDEN(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGICTRL_IDEN_SHIFT)) & USB_OTGICTRL_IDEN_MASK) + +#define USB_OTGICTRL_1MSECEN_SHIFT (6) +#define USB_OTGICTRL_1MSECEN_MASK (0x01U << USB_OTGICTRL_1MSECEN_SHIFT) +#define USB_OTGICTRL_1MSECEN(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGICTRL_1MSECEN_SHIFT)) & USB_OTGICTRL_1MSECEN_MASK) + +#define USB_OTGICTRL_LINESTATEEN_SHIFT (5) +#define USB_OTGICTRL_LINESTATEEN_MASK (0x01U << USB_OTGICTRL_LINESTATEEN_SHIFT) +#define USB_OTGICTRL_LINESTATEEN(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGICTRL_LINESTATEEN_SHIFT)) & USB_OTGICTRL_LINESTATEEN_MASK) + +#define USB_OTGICTRL_SESSVLDEN_SHIFT (3) +#define USB_OTGICTRL_SESSVLDEN_MASK (0x01U << USB_OTGICTRL_SESSVLDEN_SHIFT) +#define USB_OTGICTRL_SESSVLDEN(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGICTRL_SESSVLDEN_SHIFT)) & USB_OTGICTRL_SESSVLDEN_MASK) + +#define USB_OTGICTRL_BSESSENDEN_SHIFT (2) +#define USB_OTGICTRL_BSESSENDEN_MASK (0x01U << USB_OTGICTRL_BSESSENDEN_SHIFT) +#define USB_OTGICTRL_BSESSENDEN(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGICTRL_BSESSENDEN_SHIFT)) & USB_OTGICTRL_BSESSENDEN_MASK) + +#define USB_OTGICTRL_AVBUSVLDEN_SHIFT (0) +#define USB_OTGICTRL_AVBUSVLDEN_MASK (0x01U << USB_OTGICTRL_AVBUSVLDEN_SHIFT) +#define USB_OTGICTRL_AVBUSVLDEN(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGICTRL_AVBUSVLDEN_SHIFT)) & USB_OTGICTRL_AVBUSVLDEN_MASK) + +/*! + * @brief USB_OTGSTAT Register Bit Definition + */ + +#define USB_OTGSTAT_ID_SHIFT (7) +#define USB_OTGSTAT_ID_MASK (0x01U << USB_OTGSTAT_ID_SHIFT) +#define USB_OTGSTAT_ID(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGSTAT_ID_SHIFT)) & USB_OTGSTAT_ID_MASK) + +#define USB_OTGSTAT_1MSEC_SHIFT (6) +#define USB_OTGSTAT_1MSEC_MASK (0x01U << USB_OTGSTAT_1MSEC_SHIFT) +#define USB_OTGSTAT_1MSEC(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGSTAT_1MSEC_SHIFT)) & USB_OTGSTAT_1MSEC_MASK) + +#define USB_OTGSTAT_LINESTATESTABLE_SHIFT (5) +#define USB_OTGSTAT_LINESTATESTABLE_MASK (0x01U << USB_OTGSTAT_LINESTATESTABLE_SHIFT) +#define USB_OTGSTAT_LINESTATESTABLE(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGSTAT_LINESTATESTABLE_SHIFT)) & USB_OTGSTAT_LINESTATESTABLE_MASK) + +#define USB_OTGSTAT_SESSVLD_SHIFT (3) +#define USB_OTGSTAT_SESSVLD_MASK (0x01U << USB_OTGSTAT_SESSVLD_SHIFT) +#define USB_OTGSTAT_SESSVLD(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGSTAT_SESSVLD_SHIFT)) & USB_OTGSTAT_SESSVLD_MASK) + +#define USB_OTGSTAT_BSESSEND_SHIFT (2) +#define USB_OTGSTAT_BSESSEND_MASK (0x01U << USB_OTGSTAT_BSESSEND_SHIFT) +#define USB_OTGSTAT_BSESSEND(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGSTAT_BSESSEND_SHIFT)) & USB_OTGSTAT_BSESSEND_MASK) + +#define USB_OTGSTAT_AVBUSVLD_SHIFT (0) +#define USB_OTGSTAT_AVBUSVLD_MASK (0x01U << USB_OTGSTAT_AVBUSVLD_SHIFT) +#define USB_OTGSTAT_AVBUSVLD(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGSTAT_AVBUSVLD_SHIFT)) & USB_OTGSTAT_AVBUSVLD_MASK) + +/*! + * @brief USB_OTGCTRL Register Bit Definition + */ + +#define USB_OTGCTRL_DPHIGH_SHIFT (7) +#define USB_OTGCTRL_DPHIGH_MASK (0x01U << USB_OTGCTRL_DPHIGH_SHIFT) +#define USB_OTGCTRL_DPHIGH(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_DPHIGH_SHIFT)) & USB_OTGCTRL_DPHIGH_MASK) + +#define USB_OTGCTRL_DMHIGH_SHIFT (6) +#define USB_OTGCTRL_DMHIGH_MASK (0x01U << USB_OTGCTRL_DMHIGH_SHIFT) +#define USB_OTGCTRL_DMHIGH(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_DMHIGH_SHIFT)) & USB_OTGCTRL_DMHIGH_MASK) + +#define USB_OTGCTRL_DPLOW_SHIFT (5) +#define USB_OTGCTRL_DPLOW_MASK (0x01U << USB_OTGCTRL_DPLOW_SHIFT) +#define USB_OTGCTRL_DPLOW(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_DPLOW_SHIFT)) & USB_OTGCTRL_DPLOW_MASK) + +#define USB_OTGCTRL_DMLOW_SHIFT (4) +#define USB_OTGCTRL_DMLOW_MASK (0x01U << USB_OTGCTRL_DMLOW_SHIFT) +#define USB_OTGCTRL_DMLOW(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_DMLOW_SHIFT)) & USB_OTGCTRL_DMLOW_MASK) + +#define USB_OTGCTRL_VBUSON_SHIFT (3) +#define USB_OTGCTRL_VBUSON_MASK (0x01U << USB_OTGCTRL_VBUSON_SHIFT) +#define USB_OTGCTRL_VBUSON(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_VBUSON_SHIFT)) & USB_OTGCTRL_VBUSON_MASK) + +#define USB_OTGCTRL_OTGEN_SHIFT (2) +#define USB_OTGCTRL_OTGEN_MASK (0x01U << USB_OTGCTRL_OTGEN_SHIFT) +#define USB_OTGCTRL_OTGEN(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_OTGEN_SHIFT)) & USB_OTGCTRL_OTGEN_MASK) + +#define USB_OTGCTRL_VBUSCHG_SHIFT (1) +#define USB_OTGCTRL_VBUSCHG_MASK (0x01U << USB_OTGCTRL_VBUSCHG_SHIFT) +#define USB_OTGCTRL_VBUSCHG(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_VBUSCHG_SHIFT)) & USB_OTGCTRL_VBUSCHG_MASK) + +#define USB_OTGCTRL_VBUSDSCHG_SHIFT (0) +#define USB_OTGCTRL_VBUSDSCHG_MASK (0x01U << USB_OTGCTRL_VBUSDSCHG_SHIFT) +#define USB_OTGCTRL_VBUSDSCHG(x) (((uint32_t)(((uint32_t)(x)) << USB_OTGCTRL_VBUSDSCHG_SHIFT)) & USB_OTGCTRL_VBUSDSCHG_MASK) + +/*! + * @brief USB_INTSTAT Register Bit Definition + */ + +#define USB_INTSTAT_STALL_SHIFT (7) +#define USB_INTSTAT_STALL_MASK (0x01U << USB_INTSTAT_STALL_SHIFT) +#define USB_INTSTAT_STALL(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_STALL_SHIFT)) & USB_INTSTAT_STALL_MASK) + +#define USB_INTSTAT_ATTACH_SHIFT (6) +#define USB_INTSTAT_ATTACH_MASK (0x01U << USB_INTSTAT_ATTACH_SHIFT) +#define USB_INTSTAT_ATTACH(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_ATTACH_SHIFT)) & USB_INTSTAT_ATTACH_MASK) + +#define USB_INTSTAT_RESUME_SHIFT (5) +#define USB_INTSTAT_RESUME_MASK (0x01U << USB_INTSTAT_RESUME_SHIFT) +#define USB_INTSTAT_RESUME(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_RESUME_SHIFT)) & USB_INTSTAT_RESUME_MASK) + +#define USB_INTSTAT_SLEEP_SHIFT (4) +#define USB_INTSTAT_SLEEP_MASK (0x01U << USB_INTSTAT_SLEEP_SHIFT) +#define USB_INTSTAT_SLEEP(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_SLEEP_SHIFT)) & USB_INTSTAT_SLEEP_MASK) + +#define USB_INTSTAT_TOKDNE_SHIFT (3) +#define USB_INTSTAT_TOKDNE_MASK (0x01U << USB_INTSTAT_TOKDNE_SHIFT) +#define USB_INTSTAT_TOKDNE(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_TOKDNE_SHIFT)) & USB_INTSTAT_TOKDNE_MASK) + +#define USB_INTSTAT_SOFTOK_SHIFT (2) +#define USB_INTSTAT_SOFTOK_MASK (0x01U << USB_INTSTAT_SOFTOK_SHIFT) +#define USB_INTSTAT_SOFTOK(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_SOFTOK_SHIFT)) & USB_INTSTAT_SOFTOK_MASK) + +#define USB_INTSTAT_ERROR_SHIFT (1) +#define USB_INTSTAT_ERROR_MASK (0x01U << USB_INTSTAT_ERROR_SHIFT) +#define USB_INTSTAT_ERROR(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_ERROR_SHIFT)) & USB_INTSTAT_ERROR_MASK) + +#define USB_INTSTAT_USBRST_SHIFT (0) +#define USB_INTSTAT_USBRST_MASK (0x01U << USB_INTSTAT_USBRST_SHIFT) +#define USB_INTSTAT_USBRST(x) (((uint32_t)(((uint32_t)(x)) << USB_INTSTAT_USBRST_SHIFT)) & USB_INTSTAT_USBRST_MASK) + +/*! + * @brief USB_INTENB Register Bit Definition + */ + +#define USB_INTENB_STALL_SHIFT (7) +#define USB_INTENB_STALL_MASK (0x01U << USB_INTENB_STALL_SHIFT) +#define USB_INTENB_STALL(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_STALL_SHIFT)) & USB_INTENB_STALL_MASK) + +#define USB_INTENB_ATTACH_SHIFT (6) +#define USB_INTENB_ATTACH_MASK (0x01U << USB_INTENB_ATTACH_SHIFT) +#define USB_INTENB_ATTACH(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_ATTACH_SHIFT)) & USB_INTENB_ATTACH_MASK) + +#define USB_INTENB_RESUME_SHIFT (5) +#define USB_INTENB_RESUME_MASK (0x01U << USB_INTENB_RESUME_SHIFT) +#define USB_INTENB_RESUME(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_RESUME_SHIFT)) & USB_INTENB_RESUME_MASK) + +#define USB_INTENB_SLEEP_SHIFT (4) +#define USB_INTENB_SLEEP_MASK (0x01U << USB_INTENB_SLEEP_SHIFT) +#define USB_INTENB_SLEEP(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_SLEEP_SHIFT)) & USB_INTENB_SLEEP_MASK) + +#define USB_INTENB_TOKDNE_SHIFT (3) +#define USB_INTENB_TOKDNE_MASK (0x01U << USB_INTENB_TOKDNE_SHIFT) +#define USB_INTENB_TOKDNE(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_TOKDNE_SHIFT)) & USB_INTENB_TOKDNE_MASK) + +#define USB_INTENB_SOFTOK_SHIFT (2) +#define USB_INTENB_SOFTOK_MASK (0x01U << USB_INTENB_SOFTOK_SHIFT) +#define USB_INTENB_SOFTOK(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_SOFTOK_SHIFT)) & USB_INTENB_SOFTOK_MASK) + +#define USB_INTENB_ERROR_SHIFT (1) +#define USB_INTENB_ERROR_MASK (0x01U << USB_INTENB_ERROR_SHIFT) +#define USB_INTENB_ERROR(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_ERROR_SHIFT)) & USB_INTENB_ERROR_MASK) + +#define USB_INTENB_USBRST_SHIFT (0) +#define USB_INTENB_USBRST_MASK (0x01U << USB_INTENB_USBRST_SHIFT) +#define USB_INTENB_USBRST(x) (((uint32_t)(((uint32_t)(x)) << USB_INTENB_USBRST_SHIFT)) & USB_INTENB_USBRST_MASK) + +/*! + * @brief USB_ERRSTAT Register Bit Definition + */ + +#define USB_ERRSTAT_BTSERR_SHIFT (7) +#define USB_ERRSTAT_BTSERR_MASK (0x01U << USB_ERRSTAT_BTSERR_SHIFT) +#define USB_ERRSTAT_BTSERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRSTAT_BTSERR_SHIFT)) & USB_ERRSTAT_BTSERR_MASK) + +#define USB_ERRSTAT_DMAERR_SHIFT (5) +#define USB_ERRSTAT_DMAERR_MASK (0x01U << USB_ERRSTAT_DMAERR_SHIFT) +#define USB_ERRSTAT_DMAERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRSTAT_DMAERR_SHIFT)) & USB_ERRSTAT_DMAERR_MASK) + +#define USB_ERRSTAT_BTOERR_SHIFT (4) +#define USB_ERRSTAT_BTOERR_MASK (0x01U << USB_ERRSTAT_BTOERR_SHIFT) +#define USB_ERRSTAT_BTOERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRSTAT_BTOERR_SHIFT)) & USB_ERRSTAT_BTOERR_MASK) + +#define USB_ERRSTAT_DFN8_SHIFT (3) +#define USB_ERRSTAT_DFN8_MASK (0x01U << USB_ERRSTAT_DFN8_SHIFT) +#define USB_ERRSTAT_DFN8(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRSTAT_DFN8_SHIFT)) & USB_ERRSTAT_DFN8_MASK) + +#define USB_ERRSTAT_CRC16_SHIFT (2) +#define USB_ERRSTAT_CRC16_MASK (0x01U << USB_ERRSTAT_CRC16_SHIFT) +#define USB_ERRSTAT_CRC16(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRSTAT_CRC16_SHIFT)) & USB_ERRSTAT_CRC16_MASK) + +#define USB_ERRSTAT_CRC5EOF_SHIFT (1) +#define USB_ERRSTAT_CRC5EOF_MASK (0x01U << USB_ERRSTAT_CRC5EOF_SHIFT) +#define USB_ERRSTAT_CRC5EOF(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRSTAT_CRC5EOF_SHIFT)) & USB_ERRSTAT_CRC5EOF_MASK) + +#define USB_ERRSTAT_PIDERR_SHIFT (0) +#define USB_ERRSTAT_PIDERR_MASK (0x01U << USB_ERRSTAT_PIDERR_SHIFT) +#define USB_ERRSTAT_PIDERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRSTAT_PIDERR_SHIFT)) & USB_ERRSTAT_PIDERR_MASK) + +/*! + * @brief USB_ERRENB Register Bit Definition + */ + +#define USB_ERRENB_BTSERR_SHIFT (7) +#define USB_ERRENB_BTSERR_MASK (0x01U << USB_ERRENB_BTSERR_SHIFT) +#define USB_ERRENB_BTSERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRENB_BTSERR_SHIFT)) & USB_ERRENB_BTSERR_MASK) + +#define USB_ERRENB_DMAERR_SHIFT (5) +#define USB_ERRENB_DMAERR_MASK (0x01U << USB_ERRENB_DMAERR_SHIFT) +#define USB_ERRENB_DMAERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRENB_DMAERR_SHIFT)) & USB_ERRENB_DMAERR_MASK) + +#define USB_ERRENB_BTOERR_SHIFT (4) +#define USB_ERRENB_BTOERR_MASK (0x01U << USB_ERRENB_BTOERR_SHIFT) +#define USB_ERRENB_BTOERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRENB_BTOERR_SHIFT)) & USB_ERRENB_BTOERR_MASK) + +#define USB_ERRENB_DFN8_SHIFT (3) +#define USB_ERRENB_DFN8_MASK (0x01U << USB_ERRENB_DFN8_SHIFT) +#define USB_ERRENB_DFN8(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRENB_DFN8_SHIFT)) & USB_ERRENB_DFN8_MASK) + +#define USB_ERRENB_CRC16_SHIFT (2) +#define USB_ERRENB_CRC16_MASK (0x01U << USB_ERRENB_CRC16_SHIFT) +#define USB_ERRENB_CRC16(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRENB_CRC16_SHIFT)) & USB_ERRENB_CRC16_MASK) + +#define USB_ERRENB_CRC5EOF_SHIFT (1) +#define USB_ERRENB_CRC5EOF_MASK (0x01U << USB_ERRENB_CRC5EOF_SHIFT) +#define USB_ERRENB_CRC5EOF(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRENB_CRC5EOF_SHIFT)) & USB_ERRENB_CRC5EOF_MASK) + +#define USB_ERRENB_PIDERR_SHIFT (0) +#define USB_ERRENB_PIDERR_MASK (0x01U << USB_ERRENB_PIDERR_SHIFT) +#define USB_ERRENB_PIDERR(x) (((uint32_t)(((uint32_t)(x)) << USB_ERRENB_PIDERR_SHIFT)) & USB_ERRENB_PIDERR_MASK) + +/*! + * @brief USB_STAT Register Bit Definition + */ + +#define USB_STAT_ENDP_SHIFT (4) +#define USB_STAT_ENDP_MASK (0xFU << USB_STAT_ENDP_SHIFT) +#define USB_STAT_ENDP(x) (((uint32_t)(((uint32_t)(x)) << USB_STAT_ENDP_SHIFT)) & USB_STAT_ENDP_MASK) + +#define USB_STAT_TX_SHIFT (3) +#define USB_STAT_TX_MASK (0x01U << USB_STAT_TX_SHIFT) +#define USB_STAT_TX(x) (((uint32_t)(((uint32_t)(x)) << USB_STAT_TX_SHIFT)) & USB_STAT_TX_MASK) + +#define USB_STAT_ODD_SHIFT (2) +#define USB_STAT_ODD_MASK (0x01U << USB_STAT_ODD_SHIFT) +#define USB_STAT_ODD(x) (((uint32_t)(((uint32_t)(x)) << USB_STAT_ODD_SHIFT)) & USB_STAT_ODD_MASK) + +/*! + * @brief USB_CTL Register Bit Definition + */ + +#define USB_CTL_JSTATE_SHIFT (7) +#define USB_CTL_JSTATE_MASK (0x01U << USB_CTL_JSTATE_SHIFT) +#define USB_CTL_JSTATE(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_JSTATE_SHIFT)) & USB_CTL_JSTATE_MASK) + +#define USB_CTL_SE0_SHIFT (6) +#define USB_CTL_SE0_MASK (0x01U << USB_CTL_SE0_SHIFT) +#define USB_CTL_SE0(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_SE0_SHIFT)) & USB_CTL_SE0_MASK) + +#define USB_CTL_TXDSUSPENDTOKENBUSY_SHIFT (5) +#define USB_CTL_TXDSUSPENDTOKENBUSY_MASK (0x01U << USB_CTL_TXDSUSPENDTOKENBUSY_SHIFT) +#define USB_CTL_TXDSUSPENDTOKENBUSY(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_TXDSUSPENDTOKENBUSY_SHIFT)) & USB_CTL_TXDSUSPENDTOKENBUSY_MASK) + +#define USB_CTL_RESET_SHIFT (4) +#define USB_CTL_RESET_MASK (0x01U << USB_CTL_RESET_SHIFT) +#define USB_CTL_RESET(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_RESET_SHIFT)) & USB_CTL_RESET_MASK) + +#define USB_CTL_HOSTMODEEN_SHIFT (3) +#define USB_CTL_HOSTMODEEN_MASK (0x01U << USB_CTL_HOSTMODEEN_SHIFT) +#define USB_CTL_HOSTMODEEN(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_HOSTMODEEN_SHIFT)) & USB_CTL_HOSTMODEEN_MASK) + +#define USB_CTL_RESUME_SHIFT (2) +#define USB_CTL_RESUME_MASK (0x01U << USB_CTL_RESUME_SHIFT) +#define USB_CTL_RESUME(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_RESUME_SHIFT)) & USB_CTL_RESUME_MASK) + +#define USB_CTL_ODDRST_SHIFT (1) +#define USB_CTL_ODDRST_MASK (0x01U << USB_CTL_ODDRST_SHIFT) +#define USB_CTL_ODDRST(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_ODDRST_SHIFT)) & USB_CTL_ODDRST_MASK) + +#define USB_CTL_USBEN_SHIFT (0) +#define USB_CTL_USBEN_MASK (0x01U << USB_CTL_USBEN_SHIFT) +#define USB_CTL_USBEN(x) (((uint32_t)(((uint32_t)(x)) << USB_CTL_USBEN_SHIFT)) & USB_CTL_USBEN_MASK) + +/*! + * @brief USB_ADDR Register Bit Definition + */ + +#define USB_ADDR_LSEN_SHIFT (7) +#define USB_ADDR_LSEN_MASK (0x01U << USB_ADDR_LSEN_SHIFT) +#define USB_ADDR_LSEN(x) (((uint32_t)(((uint32_t)(x)) << USB_ADDR_LSEN_SHIFT)) & USB_ADDR_LSEN_MASK) + +#define USB_ADDR_ADDR_SHIFT (0) +#define USB_ADDR_ADDR_MASK (0x7FU << USB_ADDR_ADDR_SHIFT) +#define USB_ADDR_ADDR(x) (((uint32_t)(((uint32_t)(x)) << USB_ADDR_ADDR_SHIFT)) & USB_ADDR_ADDR_MASK) + +/*! + * @brief USB_BDTPAGE01 Register Bit Definition + */ + +#define USB_BDTPAGE01_BDTBA_SHIFT (1) +#define USB_BDTPAGE01_BDTBA_MASK (0x7FU << USB_BDTPAGE01_BDTBA_SHIFT) +#define USB_BDTPAGE01_BDTBA(x) (((uint32_t)(((uint32_t)(x)) << USB_BDTPAGE01_BDTBA_SHIFT)) & USB_BDTPAGE01_BDTBA_MASK) + +/*! + * @brief USB_FRMNUML Register Bit Definition + */ + +#define USB_FRMNUML_FRM_SHIFT (0) +#define USB_FRMNUML_FRM_MASK (0xFFU << USB_FRMNUML_FRM_SHIFT) +#define USB_FRMNUML_FRM(x) (((uint32_t)(((uint32_t)(x)) << USB_FRMNUML_FRM_SHIFT)) & USB_FRMNUML_FRM_MASK) + +/*! + * @brief USB_FRMNUMH Register Bit Definition + */ + +#define USB_FRMNUMH_FRM_SHIFT (0) +#define USB_FRMNUMH_FRM_MASK (0x7U << USB_FRMNUMH_FRM_SHIFT) +#define USB_FRMNUMH_FRM(x) (((uint32_t)(((uint32_t)(x)) << USB_FRMNUMH_FRM_SHIFT)) & USB_FRMNUMH_FRM_MASK) + +/*! + * @brief USB_TOKEN Register Bit Definition + */ + +#define USB_TOKEN_TOKENPID_SHIFT (4) +#define USB_TOKEN_TOKENPID_MASK (0xFU << USB_TOKEN_TOKENPID_SHIFT) +#define USB_TOKEN_TOKENPID(x) (((uint32_t)(((uint32_t)(x)) << USB_TOKEN_TOKENPID_SHIFT)) & USB_TOKEN_TOKENPID_MASK) + +#define USB_TOKEN_TOKENENDPT_SHIFT (0) +#define USB_TOKEN_TOKENENDPT_MASK (0xFU << USB_TOKEN_TOKENENDPT_SHIFT) +#define USB_TOKEN_TOKENENDPT(x) (((uint32_t)(((uint32_t)(x)) << USB_TOKEN_TOKENENDPT_SHIFT)) & USB_TOKEN_TOKENENDPT_MASK) + +/*! + * @brief USB_SOFTHLD Register Bit Definition + */ + +#define USB_SOFTHLD_CNT_SHIFT (0) +#define USB_SOFTHLD_CNT_MASK (0xFFU << USB_SOFTHLD_CNT_SHIFT) +#define USB_SOFTHLD_CNT(x) (((uint32_t)(((uint32_t)(x)) << USB_SOFTHLD_CNT_SHIFT)) & USB_SOFTHLD_CNT_MASK) + +/*! + * @brief USB_BDTPAGE02 Register Bit Definition + */ + +#define USB_BDTPAGE02_BDTBA_SHIFT (0) +#define USB_BDTPAGE02_BDTBA_MASK (0xFFU << USB_BDTPAGE02_BDTBA_SHIFT) +#define USB_BDTPAGE02_BDTBA(x) (((uint32_t)(((uint32_t)(x)) << USB_BDTPAGE02_BDTBA_SHIFT)) & USB_BDTPAGE02_BDTBA_MASK) + +/*! + * @brief USB_BDTPAGE03 Register Bit Definition + */ + +#define USB_BDTPAGE03_BDTBA_SHIFT (0) +#define USB_BDTPAGE03_BDTBA_MASK (0xFFU << USB_BDTPAGE03_BDTBA_SHIFT) +#define USB_BDTPAGE03_BDTBA(x) (((uint32_t)(((uint32_t)(x)) << USB_BDTPAGE03_BDTBA_SHIFT)) & USB_BDTPAGE03_BDTBA_MASK) + +/*! + * @brief USB_EPCTL Register Bit Definition + */ + +#define USB_EPCTL_HOSTWOHUB_SHIFT (7) +#define USB_EPCTL_HOSTWOHUB_MASK (0x01U << USB_EPCTL_HOSTWOHUB_SHIFT) +#define USB_EPCTL_HOSTWOHUB(x) (((uint32_t)(((uint32_t)(x)) << USB_EPCTL_HOSTWOHUB_SHIFT)) & USB_EPCTL_HOSTWOHUB_MASK) + +#define USB_EPCTL_RETRYDIS_SHIFT (6) +#define USB_EPCTL_RETRYDIS_MASK (0x01U << USB_EPCTL_RETRYDIS_SHIFT) +#define USB_EPCTL_RETRYDIS(x) (((uint32_t)(((uint32_t)(x)) << USB_EPCTL_RETRYDIS_SHIFT)) & USB_EPCTL_RETRYDIS_MASK) + +#define USB_EPCTL_EPCTLDISEPRXENEPTXEN_SHIFT (2) +#define USB_EPCTL_EPCTLDISEPRXENEPTXEN_MASK (0x7U << USB_EPCTL_EPCTLDISEPRXENEPTXEN_SHIFT) +#define USB_EPCTL_EPCTLDISEPRXENEPTXEN(x) (((uint32_t)(((uint32_t)(x)) << USB_EPCTL_EPCTLDISEPRXENEPTXEN_SHIFT)) & USB_EPCTL_EPCTLDISEPRXENEPTXEN_MASK) + +#define USB_EPCTL_EPSTALL_SHIFT (1) +#define USB_EPCTL_EPSTALL_MASK (0x01U << USB_EPCTL_EPSTALL_SHIFT) +#define USB_EPCTL_EPSTALL(x) (((uint32_t)(((uint32_t)(x)) << USB_EPCTL_EPSTALL_SHIFT)) & USB_EPCTL_EPSTALL_MASK) + +#define USB_EPCTL_EPHSHK_SHIFT (0) +#define USB_EPCTL_EPHSHK_MASK (0x01U << USB_EPCTL_EPHSHK_SHIFT) +#define USB_EPCTL_EPHSHK(x) (((uint32_t)(((uint32_t)(x)) << USB_EPCTL_EPHSHK_SHIFT)) & USB_EPCTL_EPHSHK_MASK) + +/*! + * @} + */ /* end of group USB_Register_Masks */ +/****************************************************************************** + * USB Instance +******************************************************************************/ +#define USB ((USB_Type*)USB_FS_OTG_BASE) + +/*! + * @} + */ /* end of group USB_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup ETH_Peripheral_Access_Layer ETH Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * ETH Type + ******************************************************************************/ +typedef struct { + __IO uint32_t MACCR; ///< MAC configuration register offset: 0x0000 + __IO uint32_t MACAFR; ///< MAC address filter control register offset: 0x0004 + __IO uint32_t MACHTHR; ///< MAC HASH table high register offset: 0x0008 + __IO uint32_t MACHTLR; ///< MAC HASH table low register offset: 0x000C + __IO uint32_t MACSMIAR; ///< SMI address register offset: 0x0010 + __IO uint32_t MACSMIDR; ///< SMI data register offset: 0x0014 + __IO uint32_t MACFCR; ///< MAC flow control register offset: 0x0018 + __IO uint32_t MACVLTR; ///< MAC VLAN Tag Register offset: 0x001C + __IO uint32_t Reserved25[1]; ///< Reserved + __IO uint32_t MACSR; ///< MAC status register offset: 0x0024 + __IO uint32_t Reserved26[6]; ///< Reserved + struct{ + __IO uint32_t MACAHR; ///< MAC filter address high register offset: 0x0040 + __IO uint32_t MACALR; ///< MAC filter address low register offset: 0x0044 + }MACAH_L[16]; + __IO uint32_t Reserved27[464]; ///< Reserved + struct{ + __IO uint32_t MACAHR; ///< MAC filter address high register offset: 0x0800 + __IO uint32_t MACALR; ///< MAC filter address low register offset: 0x0804 + }MACAH_H[16]; + __IO uint32_t Reserved28[480]; ///< Reserved + __IO uint32_t DMABSR; ///< DMA bus control register offset: 0x1000 + __IO uint32_t DMATXPDR; ///< DMA send polling register offset: 0x1004 + __IO uint32_t DMARXPDR; ///< DMA receive polling register offset: 0x1008 + __IO uint32_t DMARXDSAR; ///< DMA receive descriptor address register offset: 0x100C + __IO uint32_t DMATXDSAR; ///< DMA send descriptor address register offset: 0x1010 + __IO uint32_t DMASR; ///< DMA status register offset: 0x1014 + __IO uint32_t DMAMDR; ///< DMA working mode register offset: 0x0018 + __IO uint32_t DMAIR; ///< DMA interrupt register offset: 0x101C + __IO uint32_t DMAFLCR; ///< DMA frame loss statistics register offset: 0x1020 + __IO uint32_t DMAWDTR; ///< DMA watchdog timer register offset: 0x1024 + __IO uint32_t Reserved32[8]; ///< Reserved + __IO uint32_t DMACUTTXDSAR; ///< DMA current send descriptor address register offset: 0x1048 + __IO uint32_t DMACUTRXDSAR; ///< DMA current receive descriptor address registeroffset: 0x104C + __IO uint32_t DMACUTTXBFAR; ///< DMA current send buffer address register offset: 0x1050 + __IO uint32_t DMACUTRXBFAR; ///< DMA current receive buffer address register offset: 0x1054 + +} ETH_Type; + +/******************************************************************************* + * ETH Type + ******************************************************************************/ + +/*! + * @addtogroup ETH_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief ETH_MACSMIAR Register Bit Definition + */ + +#define ETH_MACSMIAR_SMIADD_SHIFT (11) +#define ETH_MACSMIAR_SMIADD_MASK (0x1FU << ETH_MACSMIAR_SMIADD_SHIFT) +#define ETH_MACSMIAR_SMIADD(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSMIAR_SMIADD_SHIFT)) & ETH_MACSMIAR_SMIADD_MASK) + +#define ETH_MACSMIAR_SMIREG_SHIFT (6) +#define ETH_MACSMIAR_SMIREG_MASK (0x1FU << ETH_MACSMIAR_SMIREG_SHIFT) +#define ETH_MACSMIAR_SMIREG(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSMIAR_SMIREG_SHIFT)) & ETH_MACSMIAR_SMIREG_MASK) + +#define ETH_MACSMIAR_SMICLK_SHIFT (2) +#define ETH_MACSMIAR_SMICLK_MASK (0xFU << ETH_MACSMIAR_SMICLK_SHIFT) +#define ETH_MACSMIAR_SMICLK(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSMIAR_SMICLK_SHIFT)) & ETH_MACSMIAR_SMICLK_MASK) + +#define ETH_MACSMIAR_SMIWR_SHIFT (1) +#define ETH_MACSMIAR_SMIWR_MASK (0x01U << ETH_MACSMIAR_SMIWR_SHIFT) +#define ETH_MACSMIAR_SMIWR(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSMIAR_SMIWR_SHIFT)) & ETH_MACSMIAR_SMIWR_MASK) + +#define ETH_MACSMIAR_SMIBY_SHIFT (0) +#define ETH_MACSMIAR_SMIBY_MASK (0x01U << ETH_MACSMIAR_SMIBY_SHIFT) +#define ETH_MACSMIAR_SMIBY(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSMIAR_SMIBY_SHIFT)) & ETH_MACSMIAR_SMIBY_MASK) + +/*! + * @brief ETH_MACSMIDR Register Bit Definition + */ + +#define ETH_MACSMIDR_SMIDATA_SHIFT (0) +#define ETH_MACSMIDR_SMIDATA_MASK (0xFFFFU << ETH_MACSMIDR_SMIDATA_SHIFT) +#define ETH_MACSMIDR_SMIDATA(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSMIDR_SMIDATA_SHIFT)) & ETH_MACSMIDR_SMIDATA_MASK) + +/*! + * @brief ETH_MACCR Register Bit Definition + */ + +#define ETH_MACCR_CST_SHIFT (25) +#define ETH_MACCR_CST_MASK (0x01U << ETH_MACCR_CST_SHIFT) +#define ETH_MACCR_CST(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_CST_SHIFT)) & ETH_MACCR_CST_MASK) + +#define ETH_MACCR_WTD_SHIFT (23) +#define ETH_MACCR_WTD_MASK (0x01U << ETH_MACCR_WTD_SHIFT) +#define ETH_MACCR_WTD(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_WTD_SHIFT)) & ETH_MACCR_WTD_MASK) + +#define ETH_MACCR_JD_SHIFT (22) +#define ETH_MACCR_JD_MASK (0x01U << ETH_MACCR_JD_SHIFT) +#define ETH_MACCR_JD(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_JD_SHIFT)) & ETH_MACCR_JD_MASK) + +#define ETH_MACCR_IFG_SHIFT (17) +#define ETH_MACCR_IFG_MASK (0x7U << ETH_MACCR_IFG_SHIFT) +#define ETH_MACCR_IFG(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_IFG_SHIFT)) & ETH_MACCR_IFG_MASK) + +#define ETH_MACCR_MCRS_SHIFT (16) +#define ETH_MACCR_MCRS_MASK (0x01U << ETH_MACCR_MCRS_SHIFT) +#define ETH_MACCR_MCRS(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_MCRS_SHIFT)) & ETH_MACCR_MCRS_MASK) + +#define ETH_MACCR_ROD_SHIFT (13) +#define ETH_MACCR_ROD_MASK (0x01U << ETH_MACCR_ROD_SHIFT) +#define ETH_MACCR_ROD(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_ROD_SHIFT)) & ETH_MACCR_ROD_MASK) + +#define ETH_MACCR_LM_SHIFT (12) +#define ETH_MACCR_LM_MASK (0x01U << ETH_MACCR_LM_SHIFT) +#define ETH_MACCR_LM(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_LM_SHIFT)) & ETH_MACCR_LM_MASK) + +#define ETH_MACCR_DM_SHIFT (11) +#define ETH_MACCR_DM_MASK (0x01U << ETH_MACCR_DM_SHIFT) +#define ETH_MACCR_DM(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_DM_SHIFT)) & ETH_MACCR_DM_MASK) + +#define ETH_MACCR_IPCO_SHIFT (10) +#define ETH_MACCR_IPCO_MASK (0x01U << ETH_MACCR_IPCO_SHIFT) +#define ETH_MACCR_IPCO(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_IPCO_SHIFT)) & ETH_MACCR_IPCO_MASK) + +#define ETH_MACCR_RETY_SHIFT (9) +#define ETH_MACCR_RETY_MASK (0x01U << ETH_MACCR_RETY_SHIFT) +#define ETH_MACCR_RETY(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_RETY_SHIFT)) & ETH_MACCR_RETY_MASK) + +#define ETH_MACCR_APCS_SHIFT (7) +#define ETH_MACCR_APCS_MASK (0x01U << ETH_MACCR_APCS_SHIFT) +#define ETH_MACCR_APCS(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_APCS_SHIFT)) & ETH_MACCR_APCS_MASK) + +#define ETH_MACCR_BL_SHIFT (5) +#define ETH_MACCR_BL_MASK (0x3U << ETH_MACCR_BL_SHIFT) +#define ETH_MACCR_BL(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_BL_SHIFT)) & ETH_MACCR_BL_MASK) + +#define ETH_MACCR_DLYC_SHIFT (4) +#define ETH_MACCR_DLYC_MASK (0x01U << ETH_MACCR_DLYC_SHIFT) +#define ETH_MACCR_DLYC(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_DLYC_SHIFT)) & ETH_MACCR_DLYC_MASK) + +#define ETH_MACCR_TE_SHIFT (3) +#define ETH_MACCR_TE_MASK (0x01U << ETH_MACCR_TE_SHIFT) +#define ETH_MACCR_TE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_TE_SHIFT)) & ETH_MACCR_TE_MASK) + +#define ETH_MACCR_RE_SHIFT (2) +#define ETH_MACCR_RE_MASK (0x01U << ETH_MACCR_RE_SHIFT) +#define ETH_MACCR_RE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACCR_RE_SHIFT)) & ETH_MACCR_RE_MASK) + +/*! + * @brief ETH_MACSR Register Bit Definition + */ + +#define ETH_MACSR_TXFF_SHIFT (25) +#define ETH_MACSR_TXFF_MASK (0x01U << ETH_MACSR_TXFF_SHIFT) +#define ETH_MACSR_TXFF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_TXFF_SHIFT)) & ETH_MACSR_TXFF_MASK) + +#define ETH_MACSR_TXFNE_SHIFT (24) +#define ETH_MACSR_TXFNE_MASK (0x01U << ETH_MACSR_TXFNE_SHIFT) +#define ETH_MACSR_TXFNE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_TXFNE_SHIFT)) & ETH_MACSR_TXFNE_MASK) + +#define ETH_MACSR_TXFWA_SHIFT (22) +#define ETH_MACSR_TXFWA_MASK (0x01U << ETH_MACSR_TXFWA_SHIFT) +#define ETH_MACSR_TXFWA(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_TXFWA_SHIFT)) & ETH_MACSR_TXFWA_MASK) + +#define ETH_MACSR_TXFRS_SHIFT (20) +#define ETH_MACSR_TXFRS_MASK (0x3U << ETH_MACSR_TXFRS_SHIFT) +#define ETH_MACSR_TXFRS(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_TXFRS_SHIFT)) & ETH_MACSR_TXFRS_MASK) + +#define ETH_MACSR_MTP_SHIFT (19) +#define ETH_MACSR_MTP_MASK (0x01U << ETH_MACSR_MTP_SHIFT) +#define ETH_MACSR_MTP(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_MTP_SHIFT)) & ETH_MACSR_MTP_MASK) + +#define ETH_MACSR_MTS_SHIFT (17) +#define ETH_MACSR_MTS_MASK (0x3U << ETH_MACSR_MTS_SHIFT) +#define ETH_MACSR_MTS(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_MTS_SHIFT)) & ETH_MACSR_MTS_MASK) + +#define ETH_MACSR_MTE_SHIFT (16) +#define ETH_MACSR_MTE_MASK (0x01U << ETH_MACSR_MTE_SHIFT) +#define ETH_MACSR_MTE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_MTE_SHIFT)) & ETH_MACSR_MTE_MASK) + +#define ETH_MACSR_RXFLL_SHIFT (8) +#define ETH_MACSR_RXFLL_MASK (0x3U << ETH_MACSR_RXFLL_SHIFT) +#define ETH_MACSR_RXFLL(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_RXFLL_SHIFT)) & ETH_MACSR_RXFLL_MASK) + +#define ETH_MACSR_RXFRS_SHIFT (5) +#define ETH_MACSR_RXFRS_MASK (0x3U << ETH_MACSR_RXFRS_SHIFT) +#define ETH_MACSR_RXFRS(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_RXFRS_SHIFT)) & ETH_MACSR_RXFRS_MASK) + +#define ETH_MACSR_RXFWA_SHIFT (4) +#define ETH_MACSR_RXFWA_MASK (0x01U << ETH_MACSR_RXFWA_SHIFT) +#define ETH_MACSR_RXFWA(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_RXFWA_SHIFT)) & ETH_MACSR_RXFWA_MASK) + +#define ETH_MACSR_MRS_SHIFT (1) +#define ETH_MACSR_MRS_MASK (0x3U << ETH_MACSR_MRS_SHIFT) +#define ETH_MACSR_MRS(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_MRS_SHIFT)) & ETH_MACSR_MRS_MASK) + +#define ETH_MACSR_MRE_SHIFT (0) +#define ETH_MACSR_MRE_MASK (0x01U << ETH_MACSR_MRE_SHIFT) +#define ETH_MACSR_MRE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACSR_MRE_SHIFT)) & ETH_MACSR_MRE_MASK) + +/*! + * @brief ETH_MACFCR Register Bit Definition + */ + +#define ETH_MACFCR_PSET_SHIFT (16) +#define ETH_MACFCR_PSET_MASK (0xFFFFU << ETH_MACFCR_PSET_SHIFT) +#define ETH_MACFCR_PSET(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACFCR_PSET_SHIFT)) & ETH_MACFCR_PSET_MASK) + +#define ETH_MACFCR_DZPQ_SHIFT (7) +#define ETH_MACFCR_DZPQ_MASK (0x01U << ETH_MACFCR_DZPQ_SHIFT) +#define ETH_MACFCR_DZPQ(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACFCR_DZPQ_SHIFT)) & ETH_MACFCR_DZPQ_MASK) + +#define ETH_MACFCR_PLT_SHIFT (4) +#define ETH_MACFCR_PLT_MASK (0x3U << ETH_MACFCR_PLT_SHIFT) +#define ETH_MACFCR_PLT(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACFCR_PLT_SHIFT)) & ETH_MACFCR_PLT_MASK) + +#define ETH_MACFCR_UP_SHIFT (3) +#define ETH_MACFCR_UP_MASK (0x01U << ETH_MACFCR_UP_SHIFT) +#define ETH_MACFCR_UP(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACFCR_UP_SHIFT)) & ETH_MACFCR_UP_MASK) + +#define ETH_MACFCR_FRE_SHIFT (2) +#define ETH_MACFCR_FRE_MASK (0x01U << ETH_MACFCR_FRE_SHIFT) +#define ETH_MACFCR_FRE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACFCR_FRE_SHIFT)) & ETH_MACFCR_FRE_MASK) + +#define ETH_MACFCR_FTE_SHIFT (1) +#define ETH_MACFCR_FTE_MASK (0x01U << ETH_MACFCR_FTE_SHIFT) +#define ETH_MACFCR_FTE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACFCR_FTE_SHIFT)) & ETH_MACFCR_FTE_MASK) + +#define ETH_MACFCR_FCBBPA_SHIFT (0) +#define ETH_MACFCR_FCBBPA_MASK (0x01U << ETH_MACFCR_FCBBPA_SHIFT) +#define ETH_MACFCR_FCBBPA(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACFCR_FCBBPA_SHIFT)) & ETH_MACFCR_FCBBPA_MASK) + +/*! + * @brief ETH_MACAFR Register Bit Definition + */ + +#define ETH_MACAFR_RALL_SHIFT (31) +#define ETH_MACAFR_RALL_MASK (0x01U << ETH_MACAFR_RALL_SHIFT) +#define ETH_MACAFR_RALL(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_RALL_SHIFT)) & ETH_MACAFR_RALL_MASK) + +#define ETH_MACAFR_VTFE_SHIFT (16) +#define ETH_MACAFR_VTFE_MASK (0x01U << ETH_MACAFR_VTFE_SHIFT) +#define ETH_MACAFR_VTFE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_VTFE_SHIFT)) & ETH_MACAFR_VTFE_MASK) + +#define ETH_MACAFR_HPF_SHIFT (10) +#define ETH_MACAFR_HPF_MASK (0x01U << ETH_MACAFR_HPF_SHIFT) +#define ETH_MACAFR_HPF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_HPF_SHIFT)) & ETH_MACAFR_HPF_MASK) + +#define ETH_MACAFR_SAF_SHIFT (9) +#define ETH_MACAFR_SAF_MASK (0x01U << ETH_MACAFR_SAF_SHIFT) +#define ETH_MACAFR_SAF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_SAF_SHIFT)) & ETH_MACAFR_SAF_MASK) + +#define ETH_MACAFR_SAIF_SHIFT (8) +#define ETH_MACAFR_SAIF_MASK (0x01U << ETH_MACAFR_SAIF_SHIFT) +#define ETH_MACAFR_SAIF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_SAIF_SHIFT)) & ETH_MACAFR_SAIF_MASK) + +#define ETH_MACAFR_PCF_SHIFT (6) +#define ETH_MACAFR_PCF_MASK (0x3U << ETH_MACAFR_PCF_SHIFT) +#define ETH_MACAFR_PCF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_PCF_SHIFT)) & ETH_MACAFR_PCF_MASK) + +#define ETH_MACAFR_DBF_SHIFT (5) +#define ETH_MACAFR_DBF_MASK (0x01U << ETH_MACAFR_DBF_SHIFT) +#define ETH_MACAFR_DBF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_DBF_SHIFT)) & ETH_MACAFR_DBF_MASK) + +#define ETH_MACAFR_PMF_SHIFT (4) +#define ETH_MACAFR_PMF_MASK (0x01U << ETH_MACAFR_PMF_SHIFT) +#define ETH_MACAFR_PMF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_PMF_SHIFT)) & ETH_MACAFR_PMF_MASK) + +#define ETH_MACAFR_DAIF_SHIFT (3) +#define ETH_MACAFR_DAIF_MASK (0x01U << ETH_MACAFR_DAIF_SHIFT) +#define ETH_MACAFR_DAIF(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_DAIF_SHIFT)) & ETH_MACAFR_DAIF_MASK) + +#define ETH_MACAFR_HM_SHIFT (2) +#define ETH_MACAFR_HM_MASK (0x01U << ETH_MACAFR_HM_SHIFT) +#define ETH_MACAFR_HM(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_HM_SHIFT)) & ETH_MACAFR_HM_MASK) + +#define ETH_MACAFR_HU_SHIFT (1) +#define ETH_MACAFR_HU_MASK (0x01U << ETH_MACAFR_HU_SHIFT) +#define ETH_MACAFR_HU(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_HU_SHIFT)) & ETH_MACAFR_HU_MASK) + +#define ETH_MACAFR_PM_SHIFT (0) +#define ETH_MACAFR_PM_MASK (0x01U << ETH_MACAFR_PM_SHIFT) +#define ETH_MACAFR_PM(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAFR_PM_SHIFT)) & ETH_MACAFR_PM_MASK) + +/*! + * @brief ETH_MACAHR0 Register Bit Definition + */ + +#define ETH_MACAHR0_ADDE_SHIFT (31) +#define ETH_MACAHR0_ADDE_MASK (0x01U << ETH_MACAHR0_ADDE_SHIFT) +#define ETH_MACAHR0_ADDE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAHR0_ADDE_SHIFT)) & ETH_MACAHR0_ADDE_MASK) + +#define ETH_MACAHR0_SELE_SHIFT (30) +#define ETH_MACAHR0_SELE_MASK (0x01U << ETH_MACAHR0_SELE_SHIFT) +#define ETH_MACAHR0_SELE(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAHR0_SELE_SHIFT)) & ETH_MACAHR0_SELE_MASK) + +#define ETH_MACAHR0_MBYTEC_SHIFT (24) +#define ETH_MACAHR0_MBYTEC_MASK (0x3FU << ETH_MACAHR0_MBYTEC_SHIFT) +#define ETH_MACAHR0_MBYTEC(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAHR0_MBYTEC_SHIFT)) & ETH_MACAHR0_MBYTEC_MASK) + +#define ETH_MACAHR0_MACADDH_SHIFT (0) +#define ETH_MACAHR0_MACADDH_MASK (0xFFFFU << ETH_MACAHR0_MACADDH_SHIFT) +#define ETH_MACAHR0_MACADDH(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACAHR0_MACADDH_SHIFT)) & ETH_MACAHR0_MACADDH_MASK) + +/*! + * @brief ETH_MACALR0 Register Bit Definition + */ + +#define ETH_MACALR0_MACADDL_SHIFT (0) +#define ETH_MACALR0_MACADDL_MASK (0xFFFFFFFFU << ETH_MACALR0_MACADDL_SHIFT) +#define ETH_MACALR0_MACADDL(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACALR0_MACADDL_SHIFT)) & ETH_MACALR0_MACADDL_MASK) + +/*! + * @brief ETH_MACHTHR Register Bit Definition + */ + +#define ETH_MACHTHR_MACHTABH_SHIFT (0) +#define ETH_MACHTHR_MACHTABH_MASK (0xFFFFFFFFU << ETH_MACHTHR_MACHTABH_SHIFT) +#define ETH_MACHTHR_MACHTABH(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACHTHR_MACHTABH_SHIFT)) & ETH_MACHTHR_MACHTABH_MASK) + +/*! + * @brief ETH_MACHTLR Register Bit Definition + */ + +#define ETH_MACHTLR_MACHTABL_SHIFT (0) +#define ETH_MACHTLR_MACHTABL_MASK (0xFFFFFFFFU << ETH_MACHTLR_MACHTABL_SHIFT) +#define ETH_MACHTLR_MACHTABL(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACHTLR_MACHTABL_SHIFT)) & ETH_MACHTLR_MACHTABL_MASK) + +/*! + * @brief ETH_MACVLTR Register Bit Definition + */ + +#define ETH_MACVLTR_VLANTAG_SHIFT (0) +#define ETH_MACVLTR_VLANTAG_MASK (0xFFFFU << ETH_MACVLTR_VLANTAG_SHIFT) +#define ETH_MACVLTR_VLANTAG(x) (((uint32_t)(((uint32_t)(x)) << ETH_MACVLTR_VLANTAG_SHIFT)) & ETH_MACVLTR_VLANTAG_MASK) + +/*! + * @brief ETH_DMAMDR Register Bit Definition + */ + +#define ETH_DMAMDR_DTCOE_SHIFT (26) +#define ETH_DMAMDR_DTCOE_MASK (0x01U << ETH_DMAMDR_DTCOE_SHIFT) +#define ETH_DMAMDR_DTCOE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_DTCOE_SHIFT)) & ETH_DMAMDR_DTCOE_MASK) + +#define ETH_DMAMDR_RSF_SHIFT (25) +#define ETH_DMAMDR_RSF_MASK (0x01U << ETH_DMAMDR_RSF_SHIFT) +#define ETH_DMAMDR_RSF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_RSF_SHIFT)) & ETH_DMAMDR_RSF_MASK) + +#define ETH_DMAMDR_DFRF_SHIFT (24) +#define ETH_DMAMDR_DFRF_MASK (0x01U << ETH_DMAMDR_DFRF_SHIFT) +#define ETH_DMAMDR_DFRF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_DFRF_SHIFT)) & ETH_DMAMDR_DFRF_MASK) + +#define ETH_DMAMDR_TSF_SHIFT (21) +#define ETH_DMAMDR_TSF_MASK (0x01U << ETH_DMAMDR_TSF_SHIFT) +#define ETH_DMAMDR_TSF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_TSF_SHIFT)) & ETH_DMAMDR_TSF_MASK) + +#define ETH_DMAMDR_FTF_SHIFT (20) +#define ETH_DMAMDR_FTF_MASK (0x01U << ETH_DMAMDR_FTF_SHIFT) +#define ETH_DMAMDR_FTF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_FTF_SHIFT)) & ETH_DMAMDR_FTF_MASK) + +#define ETH_DMAMDR_TTC_SHIFT (14) +#define ETH_DMAMDR_TTC_MASK (0x7U << ETH_DMAMDR_TTC_SHIFT) +#define ETH_DMAMDR_TTC(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_TTC_SHIFT)) & ETH_DMAMDR_TTC_MASK) + +#define ETH_DMAMDR_STT_SHIFT (13) +#define ETH_DMAMDR_STT_MASK (0x01U << ETH_DMAMDR_STT_SHIFT) +#define ETH_DMAMDR_STT(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_STT_SHIFT)) & ETH_DMAMDR_STT_MASK) + +#define ETH_DMAMDR_FEF_SHIFT (7) +#define ETH_DMAMDR_FEF_MASK (0x01U << ETH_DMAMDR_FEF_SHIFT) +#define ETH_DMAMDR_FEF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_FEF_SHIFT)) & ETH_DMAMDR_FEF_MASK) + +#define ETH_DMAMDR_FUF_SHIFT (6) +#define ETH_DMAMDR_FUF_MASK (0x01U << ETH_DMAMDR_FUF_SHIFT) +#define ETH_DMAMDR_FUF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_FUF_SHIFT)) & ETH_DMAMDR_FUF_MASK) + +#define ETH_DMAMDR_DGF_SHIFT (5) +#define ETH_DMAMDR_DGF_MASK (0x01U << ETH_DMAMDR_DGF_SHIFT) +#define ETH_DMAMDR_DGF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_DGF_SHIFT)) & ETH_DMAMDR_DGF_MASK) + +#define ETH_DMAMDR_RTC_SHIFT (3) +#define ETH_DMAMDR_RTC_MASK (0x3U << ETH_DMAMDR_RTC_SHIFT) +#define ETH_DMAMDR_RTC(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_RTC_SHIFT)) & ETH_DMAMDR_RTC_MASK) + +#define ETH_DMAMDR_OSF_SHIFT (2) +#define ETH_DMAMDR_OSF_MASK (0x01U << ETH_DMAMDR_OSF_SHIFT) +#define ETH_DMAMDR_OSF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_OSF_SHIFT)) & ETH_DMAMDR_OSF_MASK) + +#define ETH_DMAMDR_SR_SHIFT (1) +#define ETH_DMAMDR_SR_MASK (0x01U << ETH_DMAMDR_SR_SHIFT) +#define ETH_DMAMDR_SR(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAMDR_SR_SHIFT)) & ETH_DMAMDR_SR_MASK) + +/*! + * @brief ETH_DMABSR Register Bit Definition + */ + +#define ETH_DMABSR_ALL_SHIFT (25) +#define ETH_DMABSR_ALL_MASK (0x01U << ETH_DMABSR_ALL_SHIFT) +#define ETH_DMABSR_ALL(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMABSR_ALL_SHIFT)) & ETH_DMABSR_ALL_MASK) + +#define ETH_DMABSR_FBST_SHIFT (16) +#define ETH_DMABSR_FBST_MASK (0x01U << ETH_DMABSR_FBST_SHIFT) +#define ETH_DMABSR_FBST(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMABSR_FBST_SHIFT)) & ETH_DMABSR_FBST_MASK) + +#define ETH_DMABSR_FTPR_SHIFT (14) +#define ETH_DMABSR_FTPR_MASK (0x3U << ETH_DMABSR_FTPR_SHIFT) +#define ETH_DMABSR_FTPR(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMABSR_FTPR_SHIFT)) & ETH_DMABSR_FTPR_MASK) + +#define ETH_DMABSR_PBL_SHIFT (8) +#define ETH_DMABSR_PBL_MASK (0x3FU << ETH_DMABSR_PBL_SHIFT) +#define ETH_DMABSR_PBL(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMABSR_PBL_SHIFT)) & ETH_DMABSR_PBL_MASK) + +#define ETH_DMABSR_DSL_SHIFT (2) +#define ETH_DMABSR_DSL_MASK (0x1FU << ETH_DMABSR_DSL_SHIFT) +#define ETH_DMABSR_DSL(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMABSR_DSL_SHIFT)) & ETH_DMABSR_DSL_MASK) + +#define ETH_DMABSR_DMAA_SHIFT (1) +#define ETH_DMABSR_DMAA_MASK (0x01U << ETH_DMABSR_DMAA_SHIFT) +#define ETH_DMABSR_DMAA(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMABSR_DMAA_SHIFT)) & ETH_DMABSR_DMAA_MASK) + +#define ETH_DMABSR_SR_SHIFT (0) +#define ETH_DMABSR_SR_MASK (0x01U << ETH_DMABSR_SR_SHIFT) +#define ETH_DMABSR_SR(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMABSR_SR_SHIFT)) & ETH_DMABSR_SR_MASK) + +/*! + * @brief ETH_DMAIR Register Bit Definition + */ + +#define ETH_DMAIR_NIE_SHIFT (16) +#define ETH_DMAIR_NIE_MASK (0x01U << ETH_DMAIR_NIE_SHIFT) +#define ETH_DMAIR_NIE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_NIE_SHIFT)) & ETH_DMAIR_NIE_MASK) + +#define ETH_DMAIR_AIE_SHIFT (15) +#define ETH_DMAIR_AIE_MASK (0x01U << ETH_DMAIR_AIE_SHIFT) +#define ETH_DMAIR_AIE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_AIE_SHIFT)) & ETH_DMAIR_AIE_MASK) + +#define ETH_DMAIR_ERE_SHIFT (14) +#define ETH_DMAIR_ERE_MASK (0x01U << ETH_DMAIR_ERE_SHIFT) +#define ETH_DMAIR_ERE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_ERE_SHIFT)) & ETH_DMAIR_ERE_MASK) + +#define ETH_DMAIR_FBE_SHIFT (13) +#define ETH_DMAIR_FBE_MASK (0x01U << ETH_DMAIR_FBE_SHIFT) +#define ETH_DMAIR_FBE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_FBE_SHIFT)) & ETH_DMAIR_FBE_MASK) + +#define ETH_DMAIR_ETE_SHIFT (10) +#define ETH_DMAIR_ETE_MASK (0x01U << ETH_DMAIR_ETE_SHIFT) +#define ETH_DMAIR_ETE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_ETE_SHIFT)) & ETH_DMAIR_ETE_MASK) + +#define ETH_DMAIR_RWE_SHIFT (9) +#define ETH_DMAIR_RWE_MASK (0x01U << ETH_DMAIR_RWE_SHIFT) +#define ETH_DMAIR_RWE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_RWE_SHIFT)) & ETH_DMAIR_RWE_MASK) + +#define ETH_DMAIR_RSE_SHIFT (8) +#define ETH_DMAIR_RSE_MASK (0x01U << ETH_DMAIR_RSE_SHIFT) +#define ETH_DMAIR_RSE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_RSE_SHIFT)) & ETH_DMAIR_RSE_MASK) + +#define ETH_DMAIR_RUE_SHIFT (7) +#define ETH_DMAIR_RUE_MASK (0x01U << ETH_DMAIR_RUE_SHIFT) +#define ETH_DMAIR_RUE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_RUE_SHIFT)) & ETH_DMAIR_RUE_MASK) + +#define ETH_DMAIR_RIE_SHIFT (6) +#define ETH_DMAIR_RIE_MASK (0x01U << ETH_DMAIR_RIE_SHIFT) +#define ETH_DMAIR_RIE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_RIE_SHIFT)) & ETH_DMAIR_RIE_MASK) + +#define ETH_DMAIR_UNE_SHIFT (5) +#define ETH_DMAIR_UNE_MASK (0x01U << ETH_DMAIR_UNE_SHIFT) +#define ETH_DMAIR_UNE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_UNE_SHIFT)) & ETH_DMAIR_UNE_MASK) + +#define ETH_DMAIR_OVE_SHIFT (4) +#define ETH_DMAIR_OVE_MASK (0x01U << ETH_DMAIR_OVE_SHIFT) +#define ETH_DMAIR_OVE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_OVE_SHIFT)) & ETH_DMAIR_OVE_MASK) + +#define ETH_DMAIR_TJE_SHIFT (3) +#define ETH_DMAIR_TJE_MASK (0x01U << ETH_DMAIR_TJE_SHIFT) +#define ETH_DMAIR_TJE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_TJE_SHIFT)) & ETH_DMAIR_TJE_MASK) + +#define ETH_DMAIR_TUE_SHIFT (2) +#define ETH_DMAIR_TUE_MASK (0x01U << ETH_DMAIR_TUE_SHIFT) +#define ETH_DMAIR_TUE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_TUE_SHIFT)) & ETH_DMAIR_TUE_MASK) + +#define ETH_DMAIR_TSE_SHIFT (1) +#define ETH_DMAIR_TSE_MASK (0x01U << ETH_DMAIR_TSE_SHIFT) +#define ETH_DMAIR_TSE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_TSE_SHIFT)) & ETH_DMAIR_TSE_MASK) + +#define ETH_DMAIR_TIE_SHIFT (0) +#define ETH_DMAIR_TIE_MASK (0x01U << ETH_DMAIR_TIE_SHIFT) +#define ETH_DMAIR_TIE(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAIR_TIE_SHIFT)) & ETH_DMAIR_TIE_MASK) + +/*! + * @brief ETH_DMASR Register Bit Definition + */ + +#define ETH_DMASR_EBUS_SHIFT (23) +#define ETH_DMASR_EBUS_MASK (0x7U << ETH_DMASR_EBUS_SHIFT) +#define ETH_DMASR_EBUS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_EBUS_SHIFT)) & ETH_DMASR_EBUS_MASK) + +#define ETH_DMASR_TPS_SHIFT (20) +#define ETH_DMASR_TPS_MASK (0x7U << ETH_DMASR_TPS_SHIFT) +#define ETH_DMASR_TPS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_TPS_SHIFT)) & ETH_DMASR_TPS_MASK) + +#define ETH_DMASR_RPS_SHIFT (17) +#define ETH_DMASR_RPS_MASK (0x7U << ETH_DMASR_RPS_SHIFT) +#define ETH_DMASR_RPS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_RPS_SHIFT)) & ETH_DMASR_RPS_MASK) + +#define ETH_DMASR_NIS_SHIFT (16) +#define ETH_DMASR_NIS_MASK (0x01U << ETH_DMASR_NIS_SHIFT) +#define ETH_DMASR_NIS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_NIS_SHIFT)) & ETH_DMASR_NIS_MASK) + +#define ETH_DMASR_AIS_SHIFT (15) +#define ETH_DMASR_AIS_MASK (0x01U << ETH_DMASR_AIS_SHIFT) +#define ETH_DMASR_AIS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_AIS_SHIFT)) & ETH_DMASR_AIS_MASK) + +#define ETH_DMASR_ERS_SHIFT (14) +#define ETH_DMASR_ERS_MASK (0x01U << ETH_DMASR_ERS_SHIFT) +#define ETH_DMASR_ERS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_ERS_SHIFT)) & ETH_DMASR_ERS_MASK) + +#define ETH_DMASR_FBS_SHIFT (13) +#define ETH_DMASR_FBS_MASK (0x01U << ETH_DMASR_FBS_SHIFT) +#define ETH_DMASR_FBS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_FBS_SHIFT)) & ETH_DMASR_FBS_MASK) + +#define ETH_DMASR_ETS_SHIFT (10) +#define ETH_DMASR_ETS_MASK (0x01U << ETH_DMASR_ETS_SHIFT) +#define ETH_DMASR_ETS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_ETS_SHIFT)) & ETH_DMASR_ETS_MASK) + +#define ETH_DMASR_RWS_SHIFT (9) +#define ETH_DMASR_RWS_MASK (0x01U << ETH_DMASR_RWS_SHIFT) +#define ETH_DMASR_RWS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_RWS_SHIFT)) & ETH_DMASR_RWS_MASK) + +#define ETH_DMASR_RSS_SHIFT (8) +#define ETH_DMASR_RSS_MASK (0x01U << ETH_DMASR_RSS_SHIFT) +#define ETH_DMASR_RSS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_RSS_SHIFT)) & ETH_DMASR_RSS_MASK) + +#define ETH_DMASR_RUS_SHIFT (7) +#define ETH_DMASR_RUS_MASK (0x01U << ETH_DMASR_RUS_SHIFT) +#define ETH_DMASR_RUS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_RUS_SHIFT)) & ETH_DMASR_RUS_MASK) + +#define ETH_DMASR_RIS_SHIFT (6) +#define ETH_DMASR_RIS_MASK (0x01U << ETH_DMASR_RIS_SHIFT) +#define ETH_DMASR_RIS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_RIS_SHIFT)) & ETH_DMASR_RIS_MASK) + +#define ETH_DMASR_UNS_SHIFT (5) +#define ETH_DMASR_UNS_MASK (0x01U << ETH_DMASR_UNS_SHIFT) +#define ETH_DMASR_UNS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_UNS_SHIFT)) & ETH_DMASR_UNS_MASK) + +#define ETH_DMASR_OVS_SHIFT (4) +#define ETH_DMASR_OVS_MASK (0x01U << ETH_DMASR_OVS_SHIFT) +#define ETH_DMASR_OVS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_OVS_SHIFT)) & ETH_DMASR_OVS_MASK) + +#define ETH_DMASR_TJS_SHIFT (3) +#define ETH_DMASR_TJS_MASK (0x01U << ETH_DMASR_TJS_SHIFT) +#define ETH_DMASR_TJS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_TJS_SHIFT)) & ETH_DMASR_TJS_MASK) + +#define ETH_DMASR_TUS_SHIFT (2) +#define ETH_DMASR_TUS_MASK (0x01U << ETH_DMASR_TUS_SHIFT) +#define ETH_DMASR_TUS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_TUS_SHIFT)) & ETH_DMASR_TUS_MASK) + +#define ETH_DMASR_TSS_SHIFT (1) +#define ETH_DMASR_TSS_MASK (0x01U << ETH_DMASR_TSS_SHIFT) +#define ETH_DMASR_TSS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_TSS_SHIFT)) & ETH_DMASR_TSS_MASK) + +#define ETH_DMASR_TIS_SHIFT (0) +#define ETH_DMASR_TIS_MASK (0x01U << ETH_DMASR_TIS_SHIFT) +#define ETH_DMASR_TIS(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMASR_TIS_SHIFT)) & ETH_DMASR_TIS_MASK) + +/*! + * @brief ETH_DMAFLCR Register Bit Definition + */ + +#define ETH_DMAFLCR_OVFF_SHIFT (28) +#define ETH_DMAFLCR_OVFF_MASK (0x01U << ETH_DMAFLCR_OVFF_SHIFT) +#define ETH_DMAFLCR_OVFF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAFLCR_OVFF_SHIFT)) & ETH_DMAFLCR_OVFF_MASK) + +#define ETH_DMAFLCR_OVFC_SHIFT (17) +#define ETH_DMAFLCR_OVFC_MASK (0x7FFU << ETH_DMAFLCR_OVFC_SHIFT) +#define ETH_DMAFLCR_OVFC(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAFLCR_OVFC_SHIFT)) & ETH_DMAFLCR_OVFC_MASK) + +#define ETH_DMAFLCR_BNAF_SHIFT (16) +#define ETH_DMAFLCR_BNAF_MASK (0x01U << ETH_DMAFLCR_BNAF_SHIFT) +#define ETH_DMAFLCR_BNAF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAFLCR_BNAF_SHIFT)) & ETH_DMAFLCR_BNAF_MASK) + +#define ETH_DMAFLCR_BNAC_SHIFT (0) +#define ETH_DMAFLCR_BNAC_MASK (0xFFFFU << ETH_DMAFLCR_BNAC_SHIFT) +#define ETH_DMAFLCR_BNAC(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAFLCR_BNAC_SHIFT)) & ETH_DMAFLCR_BNAC_MASK) + +/*! + * @brief ETH_DMAWDTR Register Bit Definition + */ + +#define ETH_DMAWDTR_RIWT_SHIFT (0) +#define ETH_DMAWDTR_RIWT_MASK (0xFFU << ETH_DMAWDTR_RIWT_SHIFT) +#define ETH_DMAWDTR_RIWT(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMAWDTR_RIWT_SHIFT)) & ETH_DMAWDTR_RIWT_MASK) + +/*! + * @brief ETH_DMARXPDR Register Bit Definition + */ + +#define ETH_DMARXPDR_RXPD_SHIFT (0) +#define ETH_DMARXPDR_RXPD_MASK (0xFFFFFFFFU << ETH_DMARXPDR_RXPD_SHIFT) +#define ETH_DMARXPDR_RXPD(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMARXPDR_RXPD_SHIFT)) & ETH_DMARXPDR_RXPD_MASK) + +/*! + * @brief ETH_DMATXPDR Register Bit Definition + */ + +#define ETH_DMATXPDR_TXPD_SHIFT (0) +#define ETH_DMATXPDR_TXPD_MASK (0xFFFFFFFFU << ETH_DMATXPDR_TXPD_SHIFT) +#define ETH_DMATXPDR_TXPD(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMATXPDR_TXPD_SHIFT)) & ETH_DMATXPDR_TXPD_MASK) + +/*! + * @brief ETH_DMARXDSAR Register Bit Definition + */ + +#define ETH_DMARXDSAR_RXDSA_SHIFT (0) +#define ETH_DMARXDSAR_RXDSA_MASK (0xFFFFFFFFU << ETH_DMARXDSAR_RXDSA_SHIFT) +#define ETH_DMARXDSAR_RXDSA(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMARXDSAR_RXDSA_SHIFT)) & ETH_DMARXDSAR_RXDSA_MASK) + +/*! + * @brief ETH_DMATXDSAR Register Bit Definition + */ + +#define ETH_DMATXDSAR_TXDSA_SHIFT (0) +#define ETH_DMATXDSAR_TXDSA_MASK (0xFFFFFFFFU << ETH_DMATXDSAR_TXDSA_SHIFT) +#define ETH_DMATXDSAR_TXDSA(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMATXDSAR_TXDSA_SHIFT)) & ETH_DMATXDSAR_TXDSA_MASK) + +/*! + * @brief ETH_DMACUTRXDSAR Register Bit Definition + */ + +#define ETH_DMACUTRXDSAR_CUTRXDSA_SHIFT (0) +#define ETH_DMACUTRXDSAR_CUTRXDSA_MASK (0xFFFFFFFFU << ETH_DMACUTRXDSAR_CUTRXDSA_SHIFT) +#define ETH_DMACUTRXDSAR_CUTRXDSA(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMACUTRXDSAR_CUTRXDSA_SHIFT)) & ETH_DMACUTRXDSAR_CUTRXDSA_MASK) + +/*! + * @brief ETH_DMACUTTXDSAR Register Bit Definition + */ + +#define ETH_DMACUTTXDSAR_CUTTXDSA_SHIFT (0) +#define ETH_DMACUTTXDSAR_CUTTXDSA_MASK (0xFFFFFFFFU << ETH_DMACUTTXDSAR_CUTTXDSA_SHIFT) +#define ETH_DMACUTTXDSAR_CUTTXDSA(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMACUTTXDSAR_CUTTXDSA_SHIFT)) & ETH_DMACUTTXDSAR_CUTTXDSA_MASK) + +/*! + * @brief ETH_DMACUTRXBFAR Register Bit Definition + */ + +#define ETH_DMACUTRXBFAR_CUTRXBUF_SHIFT (0) +#define ETH_DMACUTRXBFAR_CUTRXBUF_MASK (0xFFFFFFFFU << ETH_DMACUTRXBFAR_CUTRXBUF_SHIFT) +#define ETH_DMACUTRXBFAR_CUTRXBUF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMACUTRXBFAR_CUTRXBUF_SHIFT)) & ETH_DMACUTRXBFAR_CUTRXBUF_MASK) + +/*! + * @brief ETH_DMACUTTXBFAR Register Bit Definition + */ + +#define ETH_DMACUTTXBFAR_CUTTXBUF_SHIFT (0) +#define ETH_DMACUTTXBFAR_CUTTXBUF_MASK (0xFFFFFFFFU << ETH_DMACUTTXBFAR_CUTTXBUF_SHIFT) +#define ETH_DMACUTTXBFAR_CUTTXBUF(x) (((uint32_t)(((uint32_t)(x)) << ETH_DMACUTTXBFAR_CUTTXBUF_SHIFT)) & ETH_DMACUTTXBFAR_CUTTXBUF_MASK) + +/*! + * @} + */ /* end of group ETH_Register_Masks */ +/****************************************************************************** + * ETH Instance +******************************************************************************/ +#define ETH ((ETH_Type*)ETHERNET_BASE) + +/*! + * @} + */ /* end of group ETH_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup SDIO_Peripheral_Access_Layer SDIO Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * SDIO Type + ******************************************************************************/ +typedef struct { + __IO uint32_t MMCCTRL; ///< MMCCTRL offset: 0x00 + __IO uint32_t MMCIO; ///< MMCIO offset: 0x04 + __IO uint32_t MMCBYTECNTL; ///< MMCBYTECNTL offset: 0x08 + __IO uint32_t MMCTRBLOCKCNT; ///< MMCTRBLOCKCNT offset: 0x0C + __IO uint32_t MMCCRCCTL; ///< MMCCRCCTL offset: 0x10 + __IO uint32_t CMDCRC; ///< CMDCRC offset: 0x14 + __IO uint32_t DATCRCL; ///< DATCRCL offset: 0x18 + __IO uint32_t DATCRCH; ///< DATCRCH offset: 0x1C + __IO uint32_t MMCPORT; ///< MMCPORT offset: 0x20 + __IO uint32_t MMCINTMASK; ///< MMCINTMASK offset: 0x24 + __IO uint32_t CLRMMCINT; ///< CLRMMCINT offset: 0x28 + __IO uint32_t MMCCARDSEL; ///< MMCCARDSEL offset: 0x2C + __IO uint32_t MMCSIQ; ///< MMCSIQ offset: 0x30 + __IO uint32_t MMCIOMBCTL; ///< MMCIOMBCTL offset: 0x34 + __IO uint32_t MMCBLOCKCNT; ///< MMCBLOCKCNT offset: 0x38 + __IO uint32_t MMCTIMEOUTCNT; ///< MMCTIMEOUTCN offset: 0x3C + __IO uint32_t CMDBUF[16]; ///< CMDBUFx (0..15) offset: 0x40 + __IO uint32_t BUFCTL; ///< BUFCTL offset: 0x80 + __IO uint32_t Reserved36[31]; ///< Reserved + __IO uint32_t DATABUF[126]; ///< DATABUF offset: 0x100 +} SDIO_Type; + +/******************************************************************************* + * SDIO Type + ******************************************************************************/ + +/*! + * @addtogroup SDIO_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief SDIO_MMCCTRL Register Bit Definition + */ + +#define SDIO_MMCCTRL_RDWTEN_SHIFT (10) +#define SDIO_MMCCTRL_RDWTEN_MASK (0x01U << SDIO_MMCCTRL_RDWTEN_SHIFT) +#define SDIO_MMCCTRL_RDWTEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_RDWTEN_SHIFT)) & SDIO_MMCCTRL_RDWTEN_MASK) + +#define SDIO_MMCCTRL_INTEN_SHIFT (9) +#define SDIO_MMCCTRL_INTEN_MASK (0x01U << SDIO_MMCCTRL_INTEN_SHIFT) +#define SDIO_MMCCTRL_INTEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_INTEN_SHIFT)) & SDIO_MMCCTRL_INTEN_MASK) + +#define SDIO_MMCCTRL_MDEN_SHIFT (8) +#define SDIO_MMCCTRL_MDEN_MASK (0x01U << SDIO_MMCCTRL_MDEN_SHIFT) +#define SDIO_MMCCTRL_MDEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_MDEN_SHIFT)) & SDIO_MMCCTRL_MDEN_MASK) + +#define SDIO_MMCCTRL_DATWT_SHIFT (7) +#define SDIO_MMCCTRL_DATWT_MASK (0x01U << SDIO_MMCCTRL_DATWT_SHIFT) +#define SDIO_MMCCTRL_DATWT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_DATWT_SHIFT)) & SDIO_MMCCTRL_DATWT_MASK) + +#define SDIO_MMCCTRL_SELPTSM_SHIFT (6) +#define SDIO_MMCCTRL_SELPTSM_MASK (0x01U << SDIO_MMCCTRL_SELPTSM_SHIFT) +#define SDIO_MMCCTRL_SELPTSM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_SELPTSM_SHIFT)) & SDIO_MMCCTRL_SELPTSM_MASK) + +#define SDIO_MMCCTRL_CLKSP_SHIFT (3) +#define SDIO_MMCCTRL_CLKSP_MASK (0x7U << SDIO_MMCCTRL_CLKSP_SHIFT) +#define SDIO_MMCCTRL_CLKSP(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_CLKSP_SHIFT)) & SDIO_MMCCTRL_CLKSP_MASK) + +#define SDIO_MMCCTRL_OUTM_SHIFT (2) +#define SDIO_MMCCTRL_OUTM_MASK (0x01U << SDIO_MMCCTRL_OUTM_SHIFT) +#define SDIO_MMCCTRL_OUTM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_OUTM_SHIFT)) & SDIO_MMCCTRL_OUTM_MASK) + +#define SDIO_MMCCTRL_SELSM_SHIFT (1) +#define SDIO_MMCCTRL_SELSM_MASK (0x01U << SDIO_MMCCTRL_SELSM_SHIFT) +#define SDIO_MMCCTRL_SELSM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_SELSM_SHIFT)) & SDIO_MMCCTRL_SELSM_MASK) + +#define SDIO_MMCCTRL_OPMSEL_SHIFT (0) +#define SDIO_MMCCTRL_OPMSEL_MASK (0x01U << SDIO_MMCCTRL_OPMSEL_SHIFT) +#define SDIO_MMCCTRL_OPMSEL(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCTRL_OPMSEL_SHIFT)) & SDIO_MMCCTRL_OPMSEL_MASK) + +/*! + * @brief SDIO_MMCIO Register Bit Definition + */ + +#define SDIO_MMCIO_CMDAF_SHIFT (9) +#define SDIO_MMCIO_CMDAF_MASK (0x01U << SDIO_MMCIO_CMDAF_SHIFT) +#define SDIO_MMCIO_CMDAF(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_CMDAF_SHIFT)) & SDIO_MMCIO_CMDAF_MASK) + +#define SDIO_MMCIO_CMDCH_SHIFT (8) +#define SDIO_MMCIO_CMDCH_MASK (0x01U << SDIO_MMCIO_CMDCH_SHIFT) +#define SDIO_MMCIO_CMDCH(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_CMDCH_SHIFT)) & SDIO_MMCIO_CMDCH_MASK) + +#define SDIO_MMCIO_AUTOCLKG_SHIFT (7) +#define SDIO_MMCIO_AUTOCLKG_MASK (0x01U << SDIO_MMCIO_AUTOCLKG_SHIFT) +#define SDIO_MMCIO_AUTOCLKG(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_AUTOCLKG_SHIFT)) & SDIO_MMCIO_AUTOCLKG_MASK) + +#define SDIO_MMCIO_ENRRESP_SHIFT (6) +#define SDIO_MMCIO_ENRRESP_MASK (0x01U << SDIO_MMCIO_ENRRESP_SHIFT) +#define SDIO_MMCIO_ENRRESP(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_ENRRESP_SHIFT)) & SDIO_MMCIO_ENRRESP_MASK) + +#define SDIO_MMCIO_PCLKG_SHIFT (5) +#define SDIO_MMCIO_PCLKG_MASK (0x01U << SDIO_MMCIO_PCLKG_SHIFT) +#define SDIO_MMCIO_PCLKG(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_PCLKG_SHIFT)) & SDIO_MMCIO_PCLKG_MASK) + +#define SDIO_MMCIO_CIDCSDRD_SHIFT (4) +#define SDIO_MMCIO_CIDCSDRD_MASK (0x01U << SDIO_MMCIO_CIDCSDRD_SHIFT) +#define SDIO_MMCIO_CIDCSDRD(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_CIDCSDRD_SHIFT)) & SDIO_MMCIO_CIDCSDRD_MASK) + +#define SDIO_MMCIO_RESPCMDSEL_SHIFT (3) +#define SDIO_MMCIO_RESPCMDSEL_MASK (0x01U << SDIO_MMCIO_RESPCMDSEL_SHIFT) +#define SDIO_MMCIO_RESPCMDSEL(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_RESPCMDSEL_SHIFT)) & SDIO_MMCIO_RESPCMDSEL_MASK) + +#define SDIO_MMCIO_AUTOTR_SHIFT (2) +#define SDIO_MMCIO_AUTOTR_MASK (0x01U << SDIO_MMCIO_AUTOTR_SHIFT) +#define SDIO_MMCIO_AUTOTR(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_AUTOTR_SHIFT)) & SDIO_MMCIO_AUTOTR_MASK) + +#define SDIO_MMCIO_TRANSFDIR_SHIFT (1) +#define SDIO_MMCIO_TRANSFDIR_MASK (0x01U << SDIO_MMCIO_TRANSFDIR_SHIFT) +#define SDIO_MMCIO_TRANSFDIR(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_TRANSFDIR_SHIFT)) & SDIO_MMCIO_TRANSFDIR_MASK) + +#define SDIO_MMCIO_AUTODATTR_SHIFT (0) +#define SDIO_MMCIO_AUTODATTR_MASK (0x01U << SDIO_MMCIO_AUTODATTR_SHIFT) +#define SDIO_MMCIO_AUTODATTR(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIO_AUTODATTR_SHIFT)) & SDIO_MMCIO_AUTODATTR_MASK) + +/*! + * @brief SDIO_MMCBYTECNTL Register Bit Definition + */ + +#define SDIO_MMCBYTECNTL_CNT_SHIFT (0) +#define SDIO_MMCBYTECNTL_CNT_MASK (0xFFFFU << SDIO_MMCBYTECNTL_CNT_SHIFT) +#define SDIO_MMCBYTECNTL_CNT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCBYTECNTL_CNT_SHIFT)) & SDIO_MMCBYTECNTL_CNT_MASK) + +/*! + * @brief SDIO_MMCTRBLOCKCNT Register Bit Definition + */ + +#define SDIO_MMCTRBLOCKCNT_CNT_SHIFT (0) +#define SDIO_MMCTRBLOCKCNT_CNT_MASK (0xFFFFU << SDIO_MMCTRBLOCKCNT_CNT_SHIFT) +#define SDIO_MMCTRBLOCKCNT_CNT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCTRBLOCKCNT_CNT_SHIFT)) & SDIO_MMCTRBLOCKCNT_CNT_MASK) + +/*! + * @brief SDIO_MMCCRCCTL Register Bit Definition + */ + +#define SDIO_MMCCRCCTL_CMDCRCEN_SHIFT (7) +#define SDIO_MMCCRCCTL_CMDCRCEN_MASK (0x01U << SDIO_MMCCRCCTL_CMDCRCEN_SHIFT) +#define SDIO_MMCCRCCTL_CMDCRCEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCRCCTL_CMDCRCEN_SHIFT)) & SDIO_MMCCRCCTL_CMDCRCEN_MASK) + +#define SDIO_MMCCRCCTL_DATCRCEN_SHIFT (6) +#define SDIO_MMCCRCCTL_DATCRCEN_MASK (0x01U << SDIO_MMCCRCCTL_DATCRCEN_SHIFT) +#define SDIO_MMCCRCCTL_DATCRCEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCRCCTL_DATCRCEN_SHIFT)) & SDIO_MMCCRCCTL_DATCRCEN_MASK) + +#define SDIO_MMCCRCCTL_ENCHK_SHIFT (5) +#define SDIO_MMCCRCCTL_ENCHK_MASK (0x01U << SDIO_MMCCRCCTL_ENCHK_SHIFT) +#define SDIO_MMCCRCCTL_ENCHK(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCRCCTL_ENCHK_SHIFT)) & SDIO_MMCCRCCTL_ENCHK_MASK) + +#define SDIO_MMCCRCCTL_ENRDMB_SHIFT (4) +#define SDIO_MMCCRCCTL_ENRDMB_MASK (0x01U << SDIO_MMCCRCCTL_ENRDMB_SHIFT) +#define SDIO_MMCCRCCTL_ENRDMB(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCRCCTL_ENRDMB_SHIFT)) & SDIO_MMCCRCCTL_ENRDMB_MASK) + +#define SDIO_MMCCRCCTL_DATCRCS_SHIFT (2) +#define SDIO_MMCCRCCTL_DATCRCS_MASK (0x3U << SDIO_MMCCRCCTL_DATCRCS_SHIFT) +#define SDIO_MMCCRCCTL_DATCRCS(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCRCCTL_DATCRCS_SHIFT)) & SDIO_MMCCRCCTL_DATCRCS_MASK) + +#define SDIO_MMCCRCCTL_CMDCRCE_SHIFT (1) +#define SDIO_MMCCRCCTL_CMDCRCE_MASK (0x01U << SDIO_MMCCRCCTL_CMDCRCE_SHIFT) +#define SDIO_MMCCRCCTL_CMDCRCE(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCRCCTL_CMDCRCE_SHIFT)) & SDIO_MMCCRCCTL_CMDCRCE_MASK) + +#define SDIO_MMCCRCCTL_DATCRCE_SHIFT (0) +#define SDIO_MMCCRCCTL_DATCRCE_MASK (0x01U << SDIO_MMCCRCCTL_DATCRCE_SHIFT) +#define SDIO_MMCCRCCTL_DATCRCE(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCRCCTL_DATCRCE_SHIFT)) & SDIO_MMCCRCCTL_DATCRCE_MASK) + +/*! + * @brief SDIO_CMDCRC Register Bit Definition + */ + +#define SDIO_CMDCRC_CMDCRCV_SHIFT (0) +#define SDIO_CMDCRC_CMDCRCV_MASK (0x7FU << SDIO_CMDCRC_CMDCRCV_SHIFT) +#define SDIO_CMDCRC_CMDCRCV(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CMDCRC_CMDCRCV_SHIFT)) & SDIO_CMDCRC_CMDCRCV_MASK) + +/*! + * @brief SDIO_DATCRCL Register Bit Definition + */ + +#define SDIO_DATCRCL_DATCRCLV_SHIFT (0) +#define SDIO_DATCRCL_DATCRCLV_MASK (0x7FU << SDIO_DATCRCL_DATCRCLV_SHIFT) +#define SDIO_DATCRCL_DATCRCLV(x) (((uint32_t)(((uint32_t)(x)) << SDIO_DATCRCL_DATCRCLV_SHIFT)) & SDIO_DATCRCL_DATCRCLV_MASK) + +/*! + * @brief SDIO_DATCRCH Register Bit Definition + */ + +#define SDIO_DATCRCH_DATCRCHV_SHIFT (0) +#define SDIO_DATCRCH_DATCRCHV_MASK (0x7FU << SDIO_DATCRCH_DATCRCHV_SHIFT) +#define SDIO_DATCRCH_DATCRCHV(x) (((uint32_t)(((uint32_t)(x)) << SDIO_DATCRCH_DATCRCHV_SHIFT)) & SDIO_DATCRCH_DATCRCHV_MASK) + +/*! + * @brief SDIO_MMCPORT Register Bit Definition + */ + +#define SDIO_MMCPORT_PCLKS_SHIFT (7) +#define SDIO_MMCPORT_PCLKS_MASK (0x01U << SDIO_MMCPORT_PCLKS_SHIFT) +#define SDIO_MMCPORT_PCLKS(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCPORT_PCLKS_SHIFT)) & SDIO_MMCPORT_PCLKS_MASK) + +#define SDIO_MMCPORT_PCMDS_SHIFT (6) +#define SDIO_MMCPORT_PCMDS_MASK (0x01U << SDIO_MMCPORT_PCMDS_SHIFT) +#define SDIO_MMCPORT_PCMDS(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCPORT_PCMDS_SHIFT)) & SDIO_MMCPORT_PCMDS_MASK) + +#define SDIO_MMCPORT_PDATS_SHIFT (5) +#define SDIO_MMCPORT_PDATS_MASK (0x01U << SDIO_MMCPORT_PDATS_SHIFT) +#define SDIO_MMCPORT_PDATS(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCPORT_PDATS_SHIFT)) & SDIO_MMCPORT_PDATS_MASK) + +#define SDIO_MMCPORT_AUTONTEN_SHIFT (4) +#define SDIO_MMCPORT_AUTONTEN_MASK (0x01U << SDIO_MMCPORT_AUTONTEN_SHIFT) +#define SDIO_MMCPORT_AUTONTEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCPORT_AUTONTEN_SHIFT)) & SDIO_MMCPORT_AUTONTEN_MASK) + +#define SDIO_MMCPORT_NTCR_SHIFT (0) +#define SDIO_MMCPORT_NTCR_MASK (0xFU << SDIO_MMCPORT_NTCR_SHIFT) +#define SDIO_MMCPORT_NTCR(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCPORT_NTCR_SHIFT)) & SDIO_MMCPORT_NTCR_MASK) + +/*! + * @brief SDIO_MMCINTMASK Register Bit Definition + */ + +#define SDIO_MMCINTMASK_D1INTM_SHIFT (8) +#define SDIO_MMCINTMASK_D1INTM_MASK (0x01U << SDIO_MMCINTMASK_D1INTM_SHIFT) +#define SDIO_MMCINTMASK_D1INTM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_D1INTM_SHIFT)) & SDIO_MMCINTMASK_D1INTM_MASK) + +#define SDIO_MMCINTMASK_CRCINTM_SHIFT (7) +#define SDIO_MMCINTMASK_CRCINTM_MASK (0x01U << SDIO_MMCINTMASK_CRCINTM_SHIFT) +#define SDIO_MMCINTMASK_CRCINTM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_CRCINTM_SHIFT)) & SDIO_MMCINTMASK_CRCINTM_MASK) + +#define SDIO_MMCINTMASK_CRTINTM_SHIFT (6) +#define SDIO_MMCINTMASK_CRTINTM_MASK (0x01U << SDIO_MMCINTMASK_CRTINTM_SHIFT) +#define SDIO_MMCINTMASK_CRTINTM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_CRTINTM_SHIFT)) & SDIO_MMCINTMASK_CRTINTM_MASK) + +#define SDIO_MMCINTMASK_MBTINTM_SHIFT (5) +#define SDIO_MMCINTMASK_MBTINTM_MASK (0x01U << SDIO_MMCINTMASK_MBTINTM_SHIFT) +#define SDIO_MMCINTMASK_MBTINTM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_MBTINTM_SHIFT)) & SDIO_MMCINTMASK_MBTINTM_MASK) + +#define SDIO_MMCINTMASK_MBDINTM_SHIFT (4) +#define SDIO_MMCINTMASK_MBDINTM_MASK (0x01U << SDIO_MMCINTMASK_MBDINTM_SHIFT) +#define SDIO_MMCINTMASK_MBDINTM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_MBDINTM_SHIFT)) & SDIO_MMCINTMASK_MBDINTM_MASK) + +#define SDIO_MMCINTMASK_CMDEINT_SHIFT (3) +#define SDIO_MMCINTMASK_CMDEINT_MASK (0x01U << SDIO_MMCINTMASK_CMDEINT_SHIFT) +#define SDIO_MMCINTMASK_CMDEINT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_CMDEINT_SHIFT)) & SDIO_MMCINTMASK_CMDEINT_MASK) + +#define SDIO_MMCINTMASK_DATEINT_SHIFT (2) +#define SDIO_MMCINTMASK_DATEINT_MASK (0x01U << SDIO_MMCINTMASK_DATEINT_SHIFT) +#define SDIO_MMCINTMASK_DATEINT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_DATEINT_SHIFT)) & SDIO_MMCINTMASK_DATEINT_MASK) + +#define SDIO_MMCINTMASK_DATDINT_SHIFT (1) +#define SDIO_MMCINTMASK_DATDINT_MASK (0x01U << SDIO_MMCINTMASK_DATDINT_SHIFT) +#define SDIO_MMCINTMASK_DATDINT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_DATDINT_SHIFT)) & SDIO_MMCINTMASK_DATDINT_MASK) + +#define SDIO_MMCINTMASK_CMDDINT_SHIFT (0) +#define SDIO_MMCINTMASK_CMDDINT_MASK (0x01U << SDIO_MMCINTMASK_CMDDINT_SHIFT) +#define SDIO_MMCINTMASK_CMDDINT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCINTMASK_CMDDINT_SHIFT)) & SDIO_MMCINTMASK_CMDDINT_MASK) + +/*! + * @brief SDIO_CLRMMCINT Register Bit Definition + */ + +#define SDIO_CLRMMCINT_D1MC_SHIFT (8) +#define SDIO_CLRMMCINT_D1MC_MASK (0x01U << SDIO_CLRMMCINT_D1MC_SHIFT) +#define SDIO_CLRMMCINT_D1MC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_D1MC_SHIFT)) & SDIO_CLRMMCINT_D1MC_MASK) + +#define SDIO_CLRMMCINT_CRCEMC_SHIFT (7) +#define SDIO_CLRMMCINT_CRCEMC_MASK (0x01U << SDIO_CLRMMCINT_CRCEMC_SHIFT) +#define SDIO_CLRMMCINT_CRCEMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_CRCEMC_SHIFT)) & SDIO_CLRMMCINT_CRCEMC_MASK) + +#define SDIO_CLRMMCINT_CRNTMC_SHIFT (6) +#define SDIO_CLRMMCINT_CRNTMC_MASK (0x01U << SDIO_CLRMMCINT_CRNTMC_SHIFT) +#define SDIO_CLRMMCINT_CRNTMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_CRNTMC_SHIFT)) & SDIO_CLRMMCINT_CRNTMC_MASK) + +#define SDIO_CLRMMCINT_MBTMC_SHIFT (5) +#define SDIO_CLRMMCINT_MBTMC_MASK (0x01U << SDIO_CLRMMCINT_MBTMC_SHIFT) +#define SDIO_CLRMMCINT_MBTMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_MBTMC_SHIFT)) & SDIO_CLRMMCINT_MBTMC_MASK) + +#define SDIO_CLRMMCINT_MBDMC_SHIFT (4) +#define SDIO_CLRMMCINT_MBDMC_MASK (0x01U << SDIO_CLRMMCINT_MBDMC_SHIFT) +#define SDIO_CLRMMCINT_MBDMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_MBDMC_SHIFT)) & SDIO_CLRMMCINT_MBDMC_MASK) + +#define SDIO_CLRMMCINT_CMDEMC_SHIFT (3) +#define SDIO_CLRMMCINT_CMDEMC_MASK (0x01U << SDIO_CLRMMCINT_CMDEMC_SHIFT) +#define SDIO_CLRMMCINT_CMDEMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_CMDEMC_SHIFT)) & SDIO_CLRMMCINT_CMDEMC_MASK) + +#define SDIO_CLRMMCINT_DATEMC_SHIFT (2) +#define SDIO_CLRMMCINT_DATEMC_MASK (0x01U << SDIO_CLRMMCINT_DATEMC_SHIFT) +#define SDIO_CLRMMCINT_DATEMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_DATEMC_SHIFT)) & SDIO_CLRMMCINT_DATEMC_MASK) + +#define SDIO_CLRMMCINT_DATDMC_SHIFT (1) +#define SDIO_CLRMMCINT_DATDMC_MASK (0x01U << SDIO_CLRMMCINT_DATDMC_SHIFT) +#define SDIO_CLRMMCINT_DATDMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_DATDMC_SHIFT)) & SDIO_CLRMMCINT_DATDMC_MASK) + +#define SDIO_CLRMMCINT_CMDDMC_SHIFT (0) +#define SDIO_CLRMMCINT_CMDDMC_MASK (0x01U << SDIO_CLRMMCINT_CMDDMC_SHIFT) +#define SDIO_CLRMMCINT_CMDDMC(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CLRMMCINT_CMDDMC_SHIFT)) & SDIO_CLRMMCINT_CMDDMC_MASK) + +/*! + * @brief SDIO_MMCCARDSEL Register Bit Definition + */ + +#define SDIO_MMCCARDSEL_CTREN_SHIFT (7) +#define SDIO_MMCCARDSEL_CTREN_MASK (0x01U << SDIO_MMCCARDSEL_CTREN_SHIFT) +#define SDIO_MMCCARDSEL_CTREN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCARDSEL_CTREN_SHIFT)) & SDIO_MMCCARDSEL_CTREN_MASK) + +#define SDIO_MMCCARDSEL_ENPCLK_SHIFT (6) +#define SDIO_MMCCARDSEL_ENPCLK_MASK (0x01U << SDIO_MMCCARDSEL_ENPCLK_SHIFT) +#define SDIO_MMCCARDSEL_ENPCLK(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCARDSEL_ENPCLK_SHIFT)) & SDIO_MMCCARDSEL_ENPCLK_MASK) + +#define SDIO_MMCCARDSEL_TSCALE_SHIFT (0) +#define SDIO_MMCCARDSEL_TSCALE_MASK (0x3FU << SDIO_MMCCARDSEL_TSCALE_SHIFT) +#define SDIO_MMCCARDSEL_TSCALE(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCCARDSEL_TSCALE_SHIFT)) & SDIO_MMCCARDSEL_TSCALE_MASK) + +/*! + * @brief SDIO_MMCSIQ Register Bit Definition + */ + +#define SDIO_MMCSIQ_PCMDS_SHIFT (7) +#define SDIO_MMCSIQ_PCMDS_MASK (0x01U << SDIO_MMCSIQ_PCMDS_SHIFT) +#define SDIO_MMCSIQ_PCMDS(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCSIQ_PCMDS_SHIFT)) & SDIO_MMCSIQ_PCMDS_MASK) + +#define SDIO_MMCSIQ_CRCSTATUS_SHIFT (4) +#define SDIO_MMCSIQ_CRCSTATUS_MASK (0x7U << SDIO_MMCSIQ_CRCSTATUS_SHIFT) +#define SDIO_MMCSIQ_CRCSTATUS(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCSIQ_CRCSTATUS_SHIFT)) & SDIO_MMCSIQ_CRCSTATUS_MASK) + +#define SDIO_MMCSIQ_PDAT3S_SHIFT (3) +#define SDIO_MMCSIQ_PDAT3S_MASK (0x01U << SDIO_MMCSIQ_PDAT3S_SHIFT) +#define SDIO_MMCSIQ_PDAT3S(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCSIQ_PDAT3S_SHIFT)) & SDIO_MMCSIQ_PDAT3S_MASK) + +#define SDIO_MMCSIQ_PDAT2S_SHIFT (2) +#define SDIO_MMCSIQ_PDAT2S_MASK (0x01U << SDIO_MMCSIQ_PDAT2S_SHIFT) +#define SDIO_MMCSIQ_PDAT2S(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCSIQ_PDAT2S_SHIFT)) & SDIO_MMCSIQ_PDAT2S_MASK) + +#define SDIO_MMCSIQ_PDAT1S_SHIFT (1) +#define SDIO_MMCSIQ_PDAT1S_MASK (0x01U << SDIO_MMCSIQ_PDAT1S_SHIFT) +#define SDIO_MMCSIQ_PDAT1S(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCSIQ_PDAT1S_SHIFT)) & SDIO_MMCSIQ_PDAT1S_MASK) + +#define SDIO_MMCSIQ_PDAT0S_SHIFT (0) +#define SDIO_MMCSIQ_PDAT0S_MASK (0x01U << SDIO_MMCSIQ_PDAT0S_SHIFT) +#define SDIO_MMCSIQ_PDAT0S(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCSIQ_PDAT0S_SHIFT)) & SDIO_MMCSIQ_PDAT0S_MASK) + +/*! + * @brief SDIO_MMCIOMBCTL Register Bit Definition + */ + +#define SDIO_MMCIOMBCTL_NTSSEL_SHIFT (6) +#define SDIO_MMCIOMBCTL_NTSSEL_MASK (0x3U << SDIO_MMCIOMBCTL_NTSSEL_SHIFT) +#define SDIO_MMCIOMBCTL_NTSSEL(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIOMBCTL_NTSSEL_SHIFT)) & SDIO_MMCIOMBCTL_NTSSEL_MASK) + +#define SDIO_MMCIOMBCTL_BTSSEL_SHIFT (4) +#define SDIO_MMCIOMBCTL_BTSSEL_MASK (0x3U << SDIO_MMCIOMBCTL_BTSSEL_SHIFT) +#define SDIO_MMCIOMBCTL_BTSSEL(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIOMBCTL_BTSSEL_SHIFT)) & SDIO_MMCIOMBCTL_BTSSEL_MASK) + +#define SDIO_MMCIOMBCTL_PCLKP_SHIFT (3) +#define SDIO_MMCIOMBCTL_PCLKP_MASK (0x01U << SDIO_MMCIOMBCTL_PCLKP_SHIFT) +#define SDIO_MMCIOMBCTL_PCLKP(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIOMBCTL_PCLKP_SHIFT)) & SDIO_MMCIOMBCTL_PCLKP_MASK) + +#define SDIO_MMCIOMBCTL_PAUTOTR_SHIFT (2) +#define SDIO_MMCIOMBCTL_PAUTOTR_MASK (0x01U << SDIO_MMCIOMBCTL_PAUTOTR_SHIFT) +#define SDIO_MMCIOMBCTL_PAUTOTR(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIOMBCTL_PAUTOTR_SHIFT)) & SDIO_MMCIOMBCTL_PAUTOTR_MASK) + +#define SDIO_MMCIOMBCTL_SMBDTD_SHIFT (1) +#define SDIO_MMCIOMBCTL_SMBDTD_MASK (0x01U << SDIO_MMCIOMBCTL_SMBDTD_SHIFT) +#define SDIO_MMCIOMBCTL_SMBDTD(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIOMBCTL_SMBDTD_SHIFT)) & SDIO_MMCIOMBCTL_SMBDTD_MASK) + +#define SDIO_MMCIOMBCTL_SPMBDTR_SHIFT (0) +#define SDIO_MMCIOMBCTL_SPMBDTR_MASK (0x01U << SDIO_MMCIOMBCTL_SPMBDTR_SHIFT) +#define SDIO_MMCIOMBCTL_SPMBDTR(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCIOMBCTL_SPMBDTR_SHIFT)) & SDIO_MMCIOMBCTL_SPMBDTR_MASK) + +/*! + * @brief SDIO_MMCBLOCKCNT Register Bit Definition + */ + +#define SDIO_MMCBLOCKCNT_BCNT_SHIFT (0) +#define SDIO_MMCBLOCKCNT_BCNT_MASK (0xFFFFU << SDIO_MMCBLOCKCNT_BCNT_SHIFT) +#define SDIO_MMCBLOCKCNT_BCNT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCBLOCKCNT_BCNT_SHIFT)) & SDIO_MMCBLOCKCNT_BCNT_MASK) + +/*! + * @brief SDIO_MMCTIMEOUTCNT Register Bit Definition + */ + +#define SDIO_MMCTIMEOUTCNT_DTCNT_SHIFT (0) +#define SDIO_MMCTIMEOUTCNT_DTCNT_MASK (0xFFU << SDIO_MMCTIMEOUTCNT_DTCNT_SHIFT) +#define SDIO_MMCTIMEOUTCNT_DTCNT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_MMCTIMEOUTCNT_DTCNT_SHIFT)) & SDIO_MMCTIMEOUTCNT_DTCNT_MASK) + +/*! + * @brief SDIO_CMDBUF Register Bit Definition + */ + +#define SDIO_CMDBUF_DAT_SHIFT (0) +#define SDIO_CMDBUF_DAT_MASK (0xFFU << SDIO_CMDBUF_DAT_SHIFT) +#define SDIO_CMDBUF_DAT(x) (((uint32_t)(((uint32_t)(x)) << SDIO_CMDBUF_DAT_SHIFT)) & SDIO_CMDBUF_DAT_MASK) + +/*! + * @brief SDIO_BUFCTL Register Bit Definition + */ + +#define SDIO_BUFCTL_DBFEN_SHIFT (15) +#define SDIO_BUFCTL_DBFEN_MASK (0x01U << SDIO_BUFCTL_DBFEN_SHIFT) +#define SDIO_BUFCTL_DBFEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_DBFEN_SHIFT)) & SDIO_BUFCTL_DBFEN_MASK) + +#define SDIO_BUFCTL_DRM_SHIFT (14) +#define SDIO_BUFCTL_DRM_MASK (0x01U << SDIO_BUFCTL_DRM_SHIFT) +#define SDIO_BUFCTL_DRM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_DRM_SHIFT)) & SDIO_BUFCTL_DRM_MASK) + +#define SDIO_BUFCTL_DFIFOSM_SHIFT (12) +#define SDIO_BUFCTL_DFIFOSM_MASK (0x01U << SDIO_BUFCTL_DFIFOSM_SHIFT) +#define SDIO_BUFCTL_DFIFOSM(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_DFIFOSM_SHIFT)) & SDIO_BUFCTL_DFIFOSM_MASK) + +#define SDIO_BUFCTL_SBAD_SHIFT (11) +#define SDIO_BUFCTL_SBAD_MASK (0x01U << SDIO_BUFCTL_SBAD_SHIFT) +#define SDIO_BUFCTL_SBAD(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_SBAD_SHIFT)) & SDIO_BUFCTL_SBAD_MASK) + +#define SDIO_BUFCTL_DMAHEN_SHIFT (10) +#define SDIO_BUFCTL_DMAHEN_MASK (0x01U << SDIO_BUFCTL_DMAHEN_SHIFT) +#define SDIO_BUFCTL_DMAHEN(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_DMAHEN_SHIFT)) & SDIO_BUFCTL_DMAHEN_MASK) + +#define SDIO_BUFCTL_DBML_SHIFT (2) +#define SDIO_BUFCTL_DBML_MASK (0xFFU << SDIO_BUFCTL_DBML_SHIFT) +#define SDIO_BUFCTL_DBML(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_DBML_SHIFT)) & SDIO_BUFCTL_DBML_MASK) + +#define SDIO_BUFCTL_DBE_SHIFT (1) +#define SDIO_BUFCTL_DBE_MASK (0x01U << SDIO_BUFCTL_DBE_SHIFT) +#define SDIO_BUFCTL_DBE(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_DBE_SHIFT)) & SDIO_BUFCTL_DBE_MASK) + +#define SDIO_BUFCTL_DBF_SHIFT (0) +#define SDIO_BUFCTL_DBF_MASK (0x01U << SDIO_BUFCTL_DBF_SHIFT) +#define SDIO_BUFCTL_DBF(x) (((uint32_t)(((uint32_t)(x)) << SDIO_BUFCTL_DBF_SHIFT)) & SDIO_BUFCTL_DBF_MASK) + +/*! + * @brief SDIO_DATABUF Register Bit Definition + */ + +#define SDIO_DATABUF_DB_SHIFT (0) +#define SDIO_DATABUF_DB_MASK (0xFFFFFFFFU << SDIO_DATABUF_DB_SHIFT) +#define SDIO_DATABUF_DB(x) (((uint32_t)(((uint32_t)(x)) << SDIO_DATABUF_DB_SHIFT)) & SDIO_DATABUF_DB_MASK) + +/*! + * @} + */ /* end of group SDIO_Register_Masks */ +/****************************************************************************** + * SDIO Instance +******************************************************************************/ +#define SDIO ((SDIO_Type*)SDIO_BASE) + +/*! + * @} + */ /* end of group SDIO_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup FSMC_Peripheral_Access_Layer FSMC Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * FSMC Type + ******************************************************************************/ +#define FSMC_SMTMGR_REG_NUM 3u /*!< the number of FSMC SMTMGR. */ +typedef struct { + __IO uint32_t Reserved37[21]; ///< Reserved + __IO uint32_t SMSKR0; ///< Memory mask register offset: 0x54 + __IO uint32_t Reserved38[15]; ///< Reserved + __IO uint32_t SMTMGRSET[FSMC_SMTMGR_REG_NUM]; ///< Memory timing register 0 offset: 0x94 + __IO uint32_t Reserved39[1]; ///< Reserved + __IO uint32_t SMCTLR; ///< Memory control register offset: 0xA4 +} FSMC_Type; + +/******************************************************************************* + * FSMC Type + ******************************************************************************/ + +/*! + * @addtogroup FSMC_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief FSMC_SMSKR0 Register Bit Definition + */ + +#define FSMC_SMSKR0_REGSELECT_SHIFT (8) +#define FSMC_SMSKR0_REGSELECT_MASK (0x7U << FSMC_SMSKR0_REGSELECT_SHIFT) +#define FSMC_SMSKR0_REGSELECT(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMSKR0_REGSELECT_SHIFT)) & FSMC_SMSKR0_REGSELECT_MASK) + +#define FSMC_SMSKR0_MEMTYPE_SHIFT (5) +#define FSMC_SMSKR0_MEMTYPE_MASK (0x7U << FSMC_SMSKR0_MEMTYPE_SHIFT) +#define FSMC_SMSKR0_MEMTYPE(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMSKR0_MEMTYPE_SHIFT)) & FSMC_SMSKR0_MEMTYPE_MASK) + +#define FSMC_SMSKR0_MEMSIZE_SHIFT (0) +#define FSMC_SMSKR0_MEMSIZE_MASK (0x1FU << FSMC_SMSKR0_MEMSIZE_SHIFT) +#define FSMC_SMSKR0_MEMSIZE(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMSKR0_MEMSIZE_SHIFT)) & FSMC_SMSKR0_MEMSIZE_MASK) + +/*! + * @brief FSMC_SMTMGRSET Register Bit Definition + */ + +#define FSMC_SMTMGRSET_SMREADPIPE_SHIFT (28) +#define FSMC_SMTMGRSET_SMREADPIPE_MASK (0x3U << FSMC_SMTMGRSET_SMREADPIPE_SHIFT) +#define FSMC_SMTMGRSET_SMREADPIPE(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMTMGRSET_SMREADPIPE_SHIFT)) & FSMC_SMTMGRSET_SMREADPIPE_MASK) + +#define FSMC_SMTMGRSET_READYMODE_SHIFT (26) +#define FSMC_SMTMGRSET_READYMODE_MASK (0x01U << FSMC_SMTMGRSET_READYMODE_SHIFT) +#define FSMC_SMTMGRSET_READYMODE(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMTMGRSET_READYMODE_SHIFT)) & FSMC_SMTMGRSET_READYMODE_MASK) + +#define FSMC_SMTMGRSET_TWP_SHIFT (10) +#define FSMC_SMTMGRSET_TWP_MASK (0x3FU << FSMC_SMTMGRSET_TWP_SHIFT) +#define FSMC_SMTMGRSET_TWP(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMTMGRSET_TWP_SHIFT)) & FSMC_SMTMGRSET_TWP_MASK) + +#define FSMC_SMTMGRSET_TWR_SHIFT (8) +#define FSMC_SMTMGRSET_TWR_MASK (0x3U << FSMC_SMTMGRSET_TWR_SHIFT) +#define FSMC_SMTMGRSET_TWR(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMTMGRSET_TWR_SHIFT)) & FSMC_SMTMGRSET_TWR_MASK) + +#define FSMC_SMTMGRSET_TAS_SHIFT (6) +#define FSMC_SMTMGRSET_TAS_MASK (0x3U << FSMC_SMTMGRSET_TAS_SHIFT) +#define FSMC_SMTMGRSET_TAS(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMTMGRSET_TAS_SHIFT)) & FSMC_SMTMGRSET_TAS_MASK) + +#define FSMC_SMTMGRSET_TRC_SHIFT (0) +#define FSMC_SMTMGRSET_TRC_MASK (0x3FU << FSMC_SMTMGRSET_TRC_SHIFT) +#define FSMC_SMTMGRSET_TRC(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMTMGRSET_TRC_SHIFT)) & FSMC_SMTMGRSET_TRC_MASK) + + +/*! + * @brief FSMC_SMCTLR Register Bit Definition + */ + +#define FSMC_SMCTLR_SMDATAWIDTHSET2_SHIFT (13) +#define FSMC_SMCTLR_SMDATAWIDTHSET2_MASK (0x7U << FSMC_SMCTLR_SMDATAWIDTHSET2_SHIFT) +#define FSMC_SMCTLR_SMDATAWIDTHSET2(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMCTLR_SMDATAWIDTHSET2_SHIFT)) & FSMC_SMCTLR_SMDATAWIDTHSET2_MASK) + +#define FSMC_SMCTLR_SMDATAWIDTHSET1_SHIFT (10) +#define FSMC_SMCTLR_SMDATAWIDTHSET1_MASK (0x7U << FSMC_SMCTLR_SMDATAWIDTHSET1_SHIFT) +#define FSMC_SMCTLR_SMDATAWIDTHSET1(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMCTLR_SMDATAWIDTHSET1_SHIFT)) & FSMC_SMCTLR_SMDATAWIDTHSET1_MASK) + +#define FSMC_SMCTLR_SMDATAWIDTHSET0_SHIFT (7) +#define FSMC_SMCTLR_SMDATAWIDTHSET0_MASK (0x7U << FSMC_SMCTLR_SMDATAWIDTHSET0_SHIFT) +#define FSMC_SMCTLR_SMDATAWIDTHSET0(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMCTLR_SMDATAWIDTHSET0_SHIFT)) & FSMC_SMCTLR_SMDATAWIDTHSET0_MASK) + +#define FSMC_SMCTLR_FLASHRP_SHIFT (0) +#define FSMC_SMCTLR_FLASHRP_MASK (0x01U << FSMC_SMCTLR_FLASHRP_SHIFT) +#define FSMC_SMCTLR_FLASHRP(x) (((uint32_t)(((uint32_t)(x)) << FSMC_SMCTLR_FLASHRP_SHIFT)) & FSMC_SMCTLR_FLASHRP_MASK) + +/*! + * @} + */ /* end of group FSMC_Register_Masks */ +/****************************************************************************** + * FSMC Instance +******************************************************************************/ +#define FSMC ((FSMC_Type*)FSMC_BASE) + +/*! + * @} + */ /* end of group FSMC_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup ADC_Peripheral_Access_Layer ADC Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * ADC Type + ******************************************************************************/ +typedef struct { + __IO uint32_t ADDATA; ///< A/D data register offset: 0x00 + __IO uint32_t ADCFG; ///< A/D configuration register offset: 0x04 + __IO uint32_t ADCR; ///< A/D control register offset: 0x08 + __IO uint32_t ADCHS; ///< A/D channel selection register offset: 0x0C + __IO uint32_t ADCMPR; ///< A/D window compare register offset: 0x10 + __IO uint32_t ADSTA; ///< A/D status register offset: 0x14 + __IO uint32_t ADDR[16]; ///< A/D data register offset: 0x18 + __IO uint32_t ADSTAEXT; ///< A/D extended status register offset: 0x58 + __IO uint32_t CHANY0; ///< A/D any channel channel selection register 0 offset: 0x5C + __IO uint32_t CHANY1; ///< A/D any channel channel selection register 1 offset: 0x60 + __IO uint32_t ANYCFG; ///< A/D arbitrary channel configuration register offset: 0x64 + __IO uint32_t ANYCR; ///< A/D arbitrary channel control register offset: 0x68 + __IO uint32_t Reserved41[1]; ///< Reserved + __IO uint32_t SMPR1; ///< A/D sampling configuration register 1 offset: 0x70 + __IO uint32_t SMPR2; ///< A/D sampling configuration register 2 offset: 0x74 + __IO uint32_t Reserved42[1]; ///< Reserved + __IO uint32_t JOFR[4]; ///< A/D injection channel data compensation registeroffset: 0x7C + __IO uint32_t JSQR; ///< A/D injection channel continuous register offset: 0x8C + __IO uint32_t JADDATA; ///< A/D injection channel data register offset: 0x90 + __IO uint32_t Reserved44[7]; ///< Reserved + __IO uint32_t JDR[4]; ///< A/D injection channel data register offset: 0xB0 +} ADC_Type; + +/******************************************************************************* + * ADC Type + ******************************************************************************/ + +/*! + * @addtogroup ADC_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief ADC_ADDATA Register Bit Definition + */ + +#define ADC_ADDATA_VALID_SHIFT (21) +#define ADC_ADDATA_VALID_MASK (0x01U << ADC_ADDATA_VALID_SHIFT) +#define ADC_ADDATA_VALID(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADDATA_VALID_SHIFT)) & ADC_ADDATA_VALID_MASK) + +#define ADC_ADDATA_OVERRUN_SHIFT (20) +#define ADC_ADDATA_OVERRUN_MASK (0x01U << ADC_ADDATA_OVERRUN_SHIFT) +#define ADC_ADDATA_OVERRUN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADDATA_OVERRUN_SHIFT)) & ADC_ADDATA_OVERRUN_MASK) + +#define ADC_ADDATA_CHANNELSEL_SHIFT (16) +#define ADC_ADDATA_CHANNELSEL_MASK (0xFU << ADC_ADDATA_CHANNELSEL_SHIFT) +#define ADC_ADDATA_CHANNELSEL(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADDATA_CHANNELSEL_SHIFT)) & ADC_ADDATA_CHANNELSEL_MASK) + +#define ADC_ADDATA_DATA_SHIFT (0) +#define ADC_ADDATA_DATA_MASK (0xFFFFU << ADC_ADDATA_DATA_SHIFT) +#define ADC_ADDATA_DATA(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADDATA_DATA_SHIFT)) & ADC_ADDATA_DATA_MASK) + +/*! + * @brief ADC_ADCFG Register Bit Definition + */ + +#define ADC_ADCFG_JADWEN_SHIFT (16) +#define ADC_ADCFG_JADWEN_MASK (0x01U << ADC_ADCFG_JADWEN_SHIFT) +#define ADC_ADCFG_JADWEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_JADWEN_SHIFT)) & ADC_ADCFG_JADWEN_MASK) + +#define ADC_ADCFG_ADCPREL_SHIFT (14) +#define ADC_ADCFG_ADCPREL_MASK (0x01U << ADC_ADCFG_ADCPREL_SHIFT) +#define ADC_ADCFG_ADCPREL(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_ADCPREL_SHIFT)) & ADC_ADCFG_ADCPREL_MASK) + +#define ADC_ADCFG_RSLTCTL_SHIFT (7) +#define ADC_ADCFG_RSLTCTL_MASK (0x7U << ADC_ADCFG_RSLTCTL_SHIFT) +#define ADC_ADCFG_RSLTCTL(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_RSLTCTL_SHIFT)) & ADC_ADCFG_RSLTCTL_MASK) + +#define ADC_ADCFG_ADCPREH_SHIFT (4) +#define ADC_ADCFG_ADCPREH_MASK (0x7U << ADC_ADCFG_ADCPREH_SHIFT) +#define ADC_ADCFG_ADCPREH(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_ADCPREH_SHIFT)) & ADC_ADCFG_ADCPREH_MASK) + +#define ADC_ADCFG_VSEN_SHIFT (3) +#define ADC_ADCFG_VSEN_MASK (0x01U << ADC_ADCFG_VSEN_SHIFT) +#define ADC_ADCFG_VSEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_VSEN_SHIFT)) & ADC_ADCFG_VSEN_MASK) + +#define ADC_ADCFG_TSEN_SHIFT (2) +#define ADC_ADCFG_TSEN_MASK (0x01U << ADC_ADCFG_TSEN_SHIFT) +#define ADC_ADCFG_TSEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_TSEN_SHIFT)) & ADC_ADCFG_TSEN_MASK) + +#define ADC_ADCFG_ADWEN_SHIFT (1) +#define ADC_ADCFG_ADWEN_MASK (0x01U << ADC_ADCFG_ADWEN_SHIFT) +#define ADC_ADCFG_ADWEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_ADWEN_SHIFT)) & ADC_ADCFG_ADWEN_MASK) + +#define ADC_ADCFG_ADEN_SHIFT (0) +#define ADC_ADCFG_ADEN_MASK (0x01U << ADC_ADCFG_ADEN_SHIFT) +#define ADC_ADCFG_ADEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCFG_ADEN_SHIFT)) & ADC_ADCFG_ADEN_MASK) + +/*! + * @brief ADC_ADCR Register Bit Definition + */ + +#define ADC_ADCR_EOCIE_SHIFT (27) +#define ADC_ADCR_EOCIE_MASK (0x01U << ADC_ADCR_EOCIE_SHIFT) +#define ADC_ADCR_EOCIE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_EOCIE_SHIFT)) & ADC_ADCR_EOCIE_MASK) + +#define ADC_ADCR_EOSMPIE_SHIFT (26) +#define ADC_ADCR_EOSMPIE_MASK (0x01U << ADC_ADCR_EOSMPIE_SHIFT) +#define ADC_ADCR_EOSMPIE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_EOSMPIE_SHIFT)) & ADC_ADCR_EOSMPIE_MASK) + +#define ADC_ADCR_TRGEDGE_SHIFT (24) +#define ADC_ADCR_TRGEDGE_MASK (0x3U << ADC_ADCR_TRGEDGE_SHIFT) +#define ADC_ADCR_TRGEDGE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_TRGEDGE_SHIFT)) & ADC_ADCR_TRGEDGE_MASK) + +#define ADC_ADCR_TRGSHIFT_SHIFT (19) +#define ADC_ADCR_TRGSHIFT_MASK (0x7U << ADC_ADCR_TRGSHIFT_SHIFT) +#define ADC_ADCR_TRGSHIFT(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_TRGSHIFT_SHIFT)) & ADC_ADCR_TRGSHIFT_MASK) + +#define ADC_ADCR_TRGSELH_SHIFT (17) +#define ADC_ADCR_TRGSELH_MASK (0x3U << ADC_ADCR_TRGSELH_SHIFT) +#define ADC_ADCR_TRGSELH(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_TRGSELH_SHIFT)) & ADC_ADCR_TRGSELH_MASK) + +#define ADC_ADCR_SCANDIR_SHIFT (16) +#define ADC_ADCR_SCANDIR_MASK (0x01U << ADC_ADCR_SCANDIR_SHIFT) +#define ADC_ADCR_SCANDIR(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_SCANDIR_SHIFT)) & ADC_ADCR_SCANDIR_MASK) + +#define ADC_ADCR_CMPCH_SHIFT (12) +#define ADC_ADCR_CMPCH_MASK (0xFU << ADC_ADCR_CMPCH_SHIFT) +#define ADC_ADCR_CMPCH(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_CMPCH_SHIFT)) & ADC_ADCR_CMPCH_MASK) + +#define ADC_ADCR_ALIGN_SHIFT (11) +#define ADC_ADCR_ALIGN_MASK (0x01U << ADC_ADCR_ALIGN_SHIFT) +#define ADC_ADCR_ALIGN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_ALIGN_SHIFT)) & ADC_ADCR_ALIGN_MASK) + +#define ADC_ADCR_ADMD_SHIFT (9) +#define ADC_ADCR_ADMD_MASK (0x3U << ADC_ADCR_ADMD_SHIFT) +#define ADC_ADCR_ADMD(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_ADMD_SHIFT)) & ADC_ADCR_ADMD_MASK) + +#define ADC_ADCR_ADST_SHIFT (8) +#define ADC_ADCR_ADST_MASK (0x01U << ADC_ADCR_ADST_SHIFT) +#define ADC_ADCR_ADST(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_ADST_SHIFT)) & ADC_ADCR_ADST_MASK) + +#define ADC_ADCR_TRGSELL_SHIFT (4) +#define ADC_ADCR_TRGSELL_MASK (0x7U << ADC_ADCR_TRGSELL_SHIFT) +#define ADC_ADCR_TRGSELL(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_TRGSELL_SHIFT)) & ADC_ADCR_TRGSELL_MASK) + +#define ADC_ADCR_DMAEN_SHIFT (3) +#define ADC_ADCR_DMAEN_MASK (0x01U << ADC_ADCR_DMAEN_SHIFT) +#define ADC_ADCR_DMAEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_DMAEN_SHIFT)) & ADC_ADCR_DMAEN_MASK) + +#define ADC_ADCR_TRGEN_SHIFT (2) +#define ADC_ADCR_TRGEN_MASK (0x01U << ADC_ADCR_TRGEN_SHIFT) +#define ADC_ADCR_TRGEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_TRGEN_SHIFT)) & ADC_ADCR_TRGEN_MASK) + +#define ADC_ADCR_ADWIE_SHIFT (1) +#define ADC_ADCR_ADWIE_MASK (0x01U << ADC_ADCR_ADWIE_SHIFT) +#define ADC_ADCR_ADWIE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_ADWIE_SHIFT)) & ADC_ADCR_ADWIE_MASK) + +#define ADC_ADCR_ADIE_SHIFT (0) +#define ADC_ADCR_ADIE_MASK (0x01U << ADC_ADCR_ADIE_SHIFT) +#define ADC_ADCR_ADIE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCR_ADIE_SHIFT)) & ADC_ADCR_ADIE_MASK) + +/*! + * @brief ADC_ADCHS Register Bit Definition + */ + +#define ADC_ADCHS_CHENVS_SHIFT (15) +#define ADC_ADCHS_CHENVS_MASK (0x01U << ADC_ADCHS_CHENVS_SHIFT) +#define ADC_ADCHS_CHENVS(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHENVS_SHIFT)) & ADC_ADCHS_CHENVS_MASK) + +#define ADC_ADCHS_CHENTS_SHIFT (14) +#define ADC_ADCHS_CHENTS_MASK (0x01U << ADC_ADCHS_CHENTS_SHIFT) +#define ADC_ADCHS_CHENTS(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHENTS_SHIFT)) & ADC_ADCHS_CHENTS_MASK) + +#define ADC_ADCHS_CHEN13_SHIFT (13) +#define ADC_ADCHS_CHEN13_MASK (0x01U << ADC_ADCHS_CHEN13_SHIFT) +#define ADC_ADCHS_CHEN13(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN13_SHIFT)) & ADC_ADCHS_CHEN13_MASK) + +#define ADC_ADCHS_CHEN12_SHIFT (12) +#define ADC_ADCHS_CHEN12_MASK (0x01U << ADC_ADCHS_CHEN12_SHIFT) +#define ADC_ADCHS_CHEN12(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN12_SHIFT)) & ADC_ADCHS_CHEN12_MASK) + +#define ADC_ADCHS_CHEN11_SHIFT (11) +#define ADC_ADCHS_CHEN11_MASK (0x01U << ADC_ADCHS_CHEN11_SHIFT) +#define ADC_ADCHS_CHEN11(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN11_SHIFT)) & ADC_ADCHS_CHEN11_MASK) + +#define ADC_ADCHS_CHEN10_SHIFT (10) +#define ADC_ADCHS_CHEN10_MASK (0x01U << ADC_ADCHS_CHEN10_SHIFT) +#define ADC_ADCHS_CHEN10(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN10_SHIFT)) & ADC_ADCHS_CHEN10_MASK) + +#define ADC_ADCHS_CHEN9_SHIFT (9) +#define ADC_ADCHS_CHEN9_MASK (0x01U << ADC_ADCHS_CHEN9_SHIFT) +#define ADC_ADCHS_CHEN9(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN9_SHIFT)) & ADC_ADCHS_CHEN9_MASK) + +#define ADC_ADCHS_CHEN8_SHIFT (8) +#define ADC_ADCHS_CHEN8_MASK (0x01U << ADC_ADCHS_CHEN8_SHIFT) +#define ADC_ADCHS_CHEN8(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN8_SHIFT)) & ADC_ADCHS_CHEN8_MASK) + +#define ADC_ADCHS_CHEN7_SHIFT (7) +#define ADC_ADCHS_CHEN7_MASK (0x01U << ADC_ADCHS_CHEN7_SHIFT) +#define ADC_ADCHS_CHEN7(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN7_SHIFT)) & ADC_ADCHS_CHEN7_MASK) + +#define ADC_ADCHS_CHEN6_SHIFT (6) +#define ADC_ADCHS_CHEN6_MASK (0x01U << ADC_ADCHS_CHEN6_SHIFT) +#define ADC_ADCHS_CHEN6(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN6_SHIFT)) & ADC_ADCHS_CHEN6_MASK) + +#define ADC_ADCHS_CHEN5_SHIFT (5) +#define ADC_ADCHS_CHEN5_MASK (0x01U << ADC_ADCHS_CHEN5_SHIFT) +#define ADC_ADCHS_CHEN5(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN5_SHIFT)) & ADC_ADCHS_CHEN5_MASK) + +#define ADC_ADCHS_CHEN4_SHIFT (4) +#define ADC_ADCHS_CHEN4_MASK (0x01U << ADC_ADCHS_CHEN4_SHIFT) +#define ADC_ADCHS_CHEN4(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN4_SHIFT)) & ADC_ADCHS_CHEN4_MASK) + +#define ADC_ADCHS_CHEN3_SHIFT (3) +#define ADC_ADCHS_CHEN3_MASK (0x01U << ADC_ADCHS_CHEN3_SHIFT) +#define ADC_ADCHS_CHEN3(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN3_SHIFT)) & ADC_ADCHS_CHEN3_MASK) + +#define ADC_ADCHS_CHEN2_SHIFT (2) +#define ADC_ADCHS_CHEN2_MASK (0x01U << ADC_ADCHS_CHEN2_SHIFT) +#define ADC_ADCHS_CHEN2(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN2_SHIFT)) & ADC_ADCHS_CHEN2_MASK) + +#define ADC_ADCHS_CHEN1_SHIFT (1) +#define ADC_ADCHS_CHEN1_MASK (0x01U << ADC_ADCHS_CHEN1_SHIFT) +#define ADC_ADCHS_CHEN1(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN1_SHIFT)) & ADC_ADCHS_CHEN1_MASK) + +#define ADC_ADCHS_CHEN0_SHIFT (0) +#define ADC_ADCHS_CHEN0_MASK (0x01U << ADC_ADCHS_CHEN0_SHIFT) +#define ADC_ADCHS_CHEN0(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCHS_CHEN0_SHIFT)) & ADC_ADCHS_CHEN0_MASK) + +/*! + * @brief ADC_ADCMPR Register Bit Definition + */ + +#define ADC_ADCMPR_CMPHDATA_SHIFT (16) +#define ADC_ADCMPR_CMPHDATA_MASK (0xFFFU << ADC_ADCMPR_CMPHDATA_SHIFT) +#define ADC_ADCMPR_CMPHDATA(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCMPR_CMPHDATA_SHIFT)) & ADC_ADCMPR_CMPHDATA_MASK) + +#define ADC_ADCMPR_CMPLDATA_SHIFT (0) +#define ADC_ADCMPR_CMPLDATA_MASK (0xFFFU << ADC_ADCMPR_CMPLDATA_SHIFT) +#define ADC_ADCMPR_CMPLDATA(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADCMPR_CMPLDATA_SHIFT)) & ADC_ADCMPR_CMPLDATA_MASK) + +/*! + * @brief ADC_ADSTA Register Bit Definition + */ + +#define ADC_ADSTA_OVERRUN_SHIFT (20) +#define ADC_ADSTA_OVERRUN_MASK (0xFFFU << ADC_ADSTA_OVERRUN_SHIFT) +#define ADC_ADSTA_OVERRUN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTA_OVERRUN_SHIFT)) & ADC_ADSTA_OVERRUN_MASK) + +#define ADC_ADSTA_VALID_SHIFT (8) +#define ADC_ADSTA_VALID_MASK (0xFFFU << ADC_ADSTA_VALID_SHIFT) +#define ADC_ADSTA_VALID(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTA_VALID_SHIFT)) & ADC_ADSTA_VALID_MASK) + +#define ADC_ADSTA_CHANNEL_SHIFT (4) +#define ADC_ADSTA_CHANNEL_MASK (0xFU << ADC_ADSTA_CHANNEL_SHIFT) +#define ADC_ADSTA_CHANNEL(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTA_CHANNEL_SHIFT)) & ADC_ADSTA_CHANNEL_MASK) + +#define ADC_ADSTA_BUSY_SHIFT (2) +#define ADC_ADSTA_BUSY_MASK (0x01U << ADC_ADSTA_BUSY_SHIFT) +#define ADC_ADSTA_BUSY(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTA_BUSY_SHIFT)) & ADC_ADSTA_BUSY_MASK) + +#define ADC_ADSTA_ADWIF_SHIFT (1) +#define ADC_ADSTA_ADWIF_MASK (0x01U << ADC_ADSTA_ADWIF_SHIFT) +#define ADC_ADSTA_ADWIF(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTA_ADWIF_SHIFT)) & ADC_ADSTA_ADWIF_MASK) + +#define ADC_ADSTA_ADIF_SHIFT (0) +#define ADC_ADSTA_ADIF_MASK (0x01U << ADC_ADSTA_ADIF_SHIFT) +#define ADC_ADSTA_ADIF(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTA_ADIF_SHIFT)) & ADC_ADSTA_ADIF_MASK) + +/*! + * @brief ADC_ADDR Register Bit Definition + */ + +#define ADC_ADDR_VALID_SHIFT (21) +#define ADC_ADDR_VALID_MASK (0x01U << ADC_ADDR_VALID_SHIFT) +#define ADC_ADDR_VALID(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADDR_VALID_SHIFT)) & ADC_ADDR_VALID_MASK) + +#define ADC_ADDR_OVERRUN_SHIFT (20) +#define ADC_ADDR_OVERRUN_MASK (0x01U << ADC_ADDR_OVERRUN_SHIFT) +#define ADC_ADDR_OVERRUN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADDR_OVERRUN_SHIFT)) & ADC_ADDR_OVERRUN_MASK) + +#define ADC_ADDR_DATA_SHIFT (0) +#define ADC_ADDR_DATA_MASK (0xFFFFU << ADC_ADDR_DATA_SHIFT) +#define ADC_ADDR_DATA(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADDR_DATA_SHIFT)) & ADC_ADDR_DATA_MASK) + +/*! + * @brief ADC_ADSTAEXT Register Bit Definition + */ + +#define ADC_ADSTAEXT_JBUSY_SHIFT (21) +#define ADC_ADSTAEXT_JBUSY_MASK (0x01U << ADC_ADSTAEXT_JBUSY_SHIFT) +#define ADC_ADSTAEXT_JBUSY(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_JBUSY_SHIFT)) & ADC_ADSTAEXT_JBUSY_MASK) + +#define ADC_ADSTAEXT_JEOSIF_SHIFT (20) +#define ADC_ADSTAEXT_JEOSIF_MASK (0x01U << ADC_ADSTAEXT_JEOSIF_SHIFT) +#define ADC_ADSTAEXT_JEOSIF(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_JEOSIF_SHIFT)) & ADC_ADSTAEXT_JEOSIF_MASK) + +#define ADC_ADSTAEXT_JEOCIF_SHIFT (19) +#define ADC_ADSTAEXT_JEOCIF_MASK (0x01U << ADC_ADSTAEXT_JEOCIF_SHIFT) +#define ADC_ADSTAEXT_JEOCIF(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_JEOCIF_SHIFT)) & ADC_ADSTAEXT_JEOCIF_MASK) + +#define ADC_ADSTAEXT_JEOSMPIF_SHIFT (18) +#define ADC_ADSTAEXT_JEOSMPIF_MASK (0x01U << ADC_ADSTAEXT_JEOSMPIF_SHIFT) +#define ADC_ADSTAEXT_JEOSMPIF(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_JEOSMPIF_SHIFT)) & ADC_ADSTAEXT_JEOSMPIF_MASK) + +#define ADC_ADSTAEXT_EOCIF_SHIFT (17) +#define ADC_ADSTAEXT_EOCIF_MASK (0x01U << ADC_ADSTAEXT_EOCIF_SHIFT) +#define ADC_ADSTAEXT_EOCIF(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_EOCIF_SHIFT)) & ADC_ADSTAEXT_EOCIF_MASK) + +#define ADC_ADSTAEXT_EOSMPIF_SHIFT (16) +#define ADC_ADSTAEXT_EOSMPIF_MASK (0x01U << ADC_ADSTAEXT_EOSMPIF_SHIFT) +#define ADC_ADSTAEXT_EOSMPIF(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_EOSMPIF_SHIFT)) & ADC_ADSTAEXT_EOSMPIF_MASK) + +#define ADC_ADSTAEXT_OVERRUN_SHIFT (4) +#define ADC_ADSTAEXT_OVERRUN_MASK (0xFU << ADC_ADSTAEXT_OVERRUN_SHIFT) +#define ADC_ADSTAEXT_OVERRUN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_OVERRUN_SHIFT)) & ADC_ADSTAEXT_OVERRUN_MASK) + +#define ADC_ADSTAEXT_VALID_SHIFT (0) +#define ADC_ADSTAEXT_VALID_MASK (0xFU << ADC_ADSTAEXT_VALID_SHIFT) +#define ADC_ADSTAEXT_VALID(x) (((uint32_t)(((uint32_t)(x)) << ADC_ADSTAEXT_VALID_SHIFT)) & ADC_ADSTAEXT_VALID_MASK) + +/*! + * @brief ADC_CHANY0 Register Bit Definition + */ + +#define ADC_CHANY0_CHANYSEL7_SHIFT (28) +#define ADC_CHANY0_CHANYSEL7_MASK (0xFU << ADC_CHANY0_CHANYSEL7_SHIFT) +#define ADC_CHANY0_CHANYSEL7(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL7_SHIFT)) & ADC_CHANY0_CHANYSEL7_MASK) + +#define ADC_CHANY0_CHANYSEL6_SHIFT (24) +#define ADC_CHANY0_CHANYSEL6_MASK (0xFU << ADC_CHANY0_CHANYSEL6_SHIFT) +#define ADC_CHANY0_CHANYSEL6(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL6_SHIFT)) & ADC_CHANY0_CHANYSEL6_MASK) + +#define ADC_CHANY0_CHANYSEL5_SHIFT (20) +#define ADC_CHANY0_CHANYSEL5_MASK (0xFU << ADC_CHANY0_CHANYSEL5_SHIFT) +#define ADC_CHANY0_CHANYSEL5(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL5_SHIFT)) & ADC_CHANY0_CHANYSEL5_MASK) + +#define ADC_CHANY0_CHANYSEL4_SHIFT (16) +#define ADC_CHANY0_CHANYSEL4_MASK (0xFU << ADC_CHANY0_CHANYSEL4_SHIFT) +#define ADC_CHANY0_CHANYSEL4(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL4_SHIFT)) & ADC_CHANY0_CHANYSEL4_MASK) + +#define ADC_CHANY0_CHANYSEL3_SHIFT (12) +#define ADC_CHANY0_CHANYSEL3_MASK (0xFU << ADC_CHANY0_CHANYSEL3_SHIFT) +#define ADC_CHANY0_CHANYSEL3(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL3_SHIFT)) & ADC_CHANY0_CHANYSEL3_MASK) + +#define ADC_CHANY0_CHANYSEL2_SHIFT (8) +#define ADC_CHANY0_CHANYSEL2_MASK (0xFU << ADC_CHANY0_CHANYSEL2_SHIFT) +#define ADC_CHANY0_CHANYSEL2(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL2_SHIFT)) & ADC_CHANY0_CHANYSEL2_MASK) + +#define ADC_CHANY0_CHANYSEL1_SHIFT (4) +#define ADC_CHANY0_CHANYSEL1_MASK (0xFU << ADC_CHANY0_CHANYSEL1_SHIFT) +#define ADC_CHANY0_CHANYSEL1(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL1_SHIFT)) & ADC_CHANY0_CHANYSEL1_MASK) + +#define ADC_CHANY0_CHANYSEL0_SHIFT (0) +#define ADC_CHANY0_CHANYSEL0_MASK (0xFU << ADC_CHANY0_CHANYSEL0_SHIFT) +#define ADC_CHANY0_CHANYSEL0(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY0_CHANYSEL0_SHIFT)) & ADC_CHANY0_CHANYSEL0_MASK) + +/*! + * @brief ADC_CHANY1 Register Bit Definition + */ + +#define ADC_CHANY1_CHANYSEL15_SHIFT (28) +#define ADC_CHANY1_CHANYSEL15_MASK (0xFU << ADC_CHANY1_CHANYSEL15_SHIFT) +#define ADC_CHANY1_CHANYSEL15(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL15_SHIFT)) & ADC_CHANY1_CHANYSEL15_MASK) + +#define ADC_CHANY1_CHANYSEL14_SHIFT (24) +#define ADC_CHANY1_CHANYSEL14_MASK (0xFU << ADC_CHANY1_CHANYSEL14_SHIFT) +#define ADC_CHANY1_CHANYSEL14(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL14_SHIFT)) & ADC_CHANY1_CHANYSEL14_MASK) + +#define ADC_CHANY1_CHANYSEL13_SHIFT (20) +#define ADC_CHANY1_CHANYSEL13_MASK (0xFU << ADC_CHANY1_CHANYSEL13_SHIFT) +#define ADC_CHANY1_CHANYSEL13(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL13_SHIFT)) & ADC_CHANY1_CHANYSEL13_MASK) + +#define ADC_CHANY1_CHANYSEL12_SHIFT (16) +#define ADC_CHANY1_CHANYSEL12_MASK (0xFU << ADC_CHANY1_CHANYSEL12_SHIFT) +#define ADC_CHANY1_CHANYSEL12(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL12_SHIFT)) & ADC_CHANY1_CHANYSEL12_MASK) + +#define ADC_CHANY1_CHANYSEL11_SHIFT (12) +#define ADC_CHANY1_CHANYSEL11_MASK (0xFU << ADC_CHANY1_CHANYSEL11_SHIFT) +#define ADC_CHANY1_CHANYSEL11(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL11_SHIFT)) & ADC_CHANY1_CHANYSEL11_MASK) + +#define ADC_CHANY1_CHANYSEL10_SHIFT (8) +#define ADC_CHANY1_CHANYSEL10_MASK (0xFU << ADC_CHANY1_CHANYSEL10_SHIFT) +#define ADC_CHANY1_CHANYSEL10(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL10_SHIFT)) & ADC_CHANY1_CHANYSEL10_MASK) + +#define ADC_CHANY1_CHANYSEL9_SHIFT (4) +#define ADC_CHANY1_CHANYSEL9_MASK (0xFU << ADC_CHANY1_CHANYSEL9_SHIFT) +#define ADC_CHANY1_CHANYSEL9(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL9_SHIFT)) & ADC_CHANY1_CHANYSEL9_MASK) + +#define ADC_CHANY1_CHANYSEL8_SHIFT (0) +#define ADC_CHANY1_CHANYSEL8_MASK (0xFU << ADC_CHANY1_CHANYSEL8_SHIFT) +#define ADC_CHANY1_CHANYSEL8(x) (((uint32_t)(((uint32_t)(x)) << ADC_CHANY1_CHANYSEL8_SHIFT)) & ADC_CHANY1_CHANYSEL8_MASK) + +/*! + * @brief ADC_ANYCFG Register Bit Definition + */ + +#define ADC_ANYCFG_CHANYNUM_SHIFT (0) +#define ADC_ANYCFG_CHANYNUM_MASK (0xFU << ADC_ANYCFG_CHANYNUM_SHIFT) +#define ADC_ANYCFG_CHANYNUM(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCFG_CHANYNUM_SHIFT)) & ADC_ANYCFG_CHANYNUM_MASK) + +/*! + * @brief ADC_ANYCR Register Bit Definition + */ + +#define ADC_ANYCR_JTRGEDGE_SHIFT (16) +#define ADC_ANYCR_JTRGEDGE_MASK (0x3U << ADC_ANYCR_JTRGEDGE_SHIFT) +#define ADC_ANYCR_JTRGEDGE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JTRGEDGE_SHIFT)) & ADC_ANYCR_JTRGEDGE_MASK) + +#define ADC_ANYCR_JTRGSHIFT_SHIFT (13) +#define ADC_ANYCR_JTRGSHIFT_MASK (0x7U << ADC_ANYCR_JTRGSHIFT_SHIFT) +#define ADC_ANYCR_JTRGSHIFT(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JTRGSHIFT_SHIFT)) & ADC_ANYCR_JTRGSHIFT_MASK) + +#define ADC_ANYCR_JTRGSEL_SHIFT (8) +#define ADC_ANYCR_JTRGSEL_MASK (0x7U << ADC_ANYCR_JTRGSEL_SHIFT) +#define ADC_ANYCR_JTRGSEL(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JTRGSEL_SHIFT)) & ADC_ANYCR_JTRGSEL_MASK) + +#define ADC_ANYCR_JTRGEN_SHIFT (7) +#define ADC_ANYCR_JTRGEN_MASK (0x01U << ADC_ANYCR_JTRGEN_SHIFT) +#define ADC_ANYCR_JTRGEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JTRGEN_SHIFT)) & ADC_ANYCR_JTRGEN_MASK) + +#define ADC_ANYCR_JADST_SHIFT (6) +#define ADC_ANYCR_JADST_MASK (0x01U << ADC_ANYCR_JADST_SHIFT) +#define ADC_ANYCR_JADST(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JADST_SHIFT)) & ADC_ANYCR_JADST_MASK) + +#define ADC_ANYCR_JAUTO_SHIFT (5) +#define ADC_ANYCR_JAUTO_MASK (0x01U << ADC_ANYCR_JAUTO_SHIFT) +#define ADC_ANYCR_JAUTO(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JAUTO_SHIFT)) & ADC_ANYCR_JAUTO_MASK) + +#define ADC_ANYCR_JEOSIE_SHIFT (4) +#define ADC_ANYCR_JEOSIE_MASK (0x01U << ADC_ANYCR_JEOSIE_SHIFT) +#define ADC_ANYCR_JEOSIE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JEOSIE_SHIFT)) & ADC_ANYCR_JEOSIE_MASK) + +#define ADC_ANYCR_JEOCIE_SHIFT (3) +#define ADC_ANYCR_JEOCIE_MASK (0x01U << ADC_ANYCR_JEOCIE_SHIFT) +#define ADC_ANYCR_JEOCIE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JEOCIE_SHIFT)) & ADC_ANYCR_JEOCIE_MASK) + +#define ADC_ANYCR_JEOSMPIE_SHIFT (2) +#define ADC_ANYCR_JEOSMPIE_MASK (0x01U << ADC_ANYCR_JEOSMPIE_SHIFT) +#define ADC_ANYCR_JEOSMPIE(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JEOSMPIE_SHIFT)) & ADC_ANYCR_JEOSMPIE_MASK) + +#define ADC_ANYCR_JCEN_SHIFT (1) +#define ADC_ANYCR_JCEN_MASK (0x01U << ADC_ANYCR_JCEN_SHIFT) +#define ADC_ANYCR_JCEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_JCEN_SHIFT)) & ADC_ANYCR_JCEN_MASK) + +#define ADC_ANYCR_CHANYMDEN_SHIFT (0) +#define ADC_ANYCR_CHANYMDEN_MASK (0x01U << ADC_ANYCR_CHANYMDEN_SHIFT) +#define ADC_ANYCR_CHANYMDEN(x) (((uint32_t)(((uint32_t)(x)) << ADC_ANYCR_CHANYMDEN_SHIFT)) & ADC_ANYCR_CHANYMDEN_MASK) + +/*! + * @brief ADC_SMPR1 Register Bit Definition + */ + +#define ADC_SMPR1_SAMCTLX_SHIFT (0) +#define ADC_SMPR1_SAMCTLX_MASK (0xFFFFFFFFU << ADC_SMPR1_SAMCTLX_SHIFT) +#define ADC_SMPR1_SAMCTLX(x) (((uint32_t)(((uint32_t)(x)) << ADC_SMPR1_SAMCTLX_SHIFT)) & ADC_SMPR1_SAMCTLX_MASK) + +/*! + * @brief ADC_SMPR2 Register Bit Definition + */ + +#define ADC_SMPR2_SAMCTLX_SHIFT (0) +#define ADC_SMPR2_SAMCTLX_MASK (0xFFFFFFFFU << ADC_SMPR2_SAMCTLX_SHIFT) +#define ADC_SMPR2_SAMCTLX(x) (((uint32_t)(((uint32_t)(x)) << ADC_SMPR2_SAMCTLX_SHIFT)) & ADC_SMPR2_SAMCTLX_MASK) + +/*! + * @brief ADC_JOFR Register Bit Definition + */ + +#define ADC_JOFR_JOFR_SHIFT (0) +#define ADC_JOFR_JOFR_MASK (0xFFFU << ADC_JOFR_JOFR_SHIFT) +#define ADC_JOFR_JOFR(x) (((uint32_t)(((uint32_t)(x)) << ADC_JOFR_JOFR_SHIFT)) & ADC_JOFR_JOFR_MASK) + +/*! + * @brief ADC_JSQR Register Bit Definition + */ + +#define ADC_JSQR_JNUM_SHIFT (20) +#define ADC_JSQR_JNUM_MASK (0x3U << ADC_JSQR_JNUM_SHIFT) +#define ADC_JSQR_JNUM(x) (((uint32_t)(((uint32_t)(x)) << ADC_JSQR_JNUM_SHIFT)) & ADC_JSQR_JNUM_MASK) + +#define ADC_JSQR_JSQ3_SHIFT (15) +#define ADC_JSQR_JSQ3_MASK (0x1FU << ADC_JSQR_JSQ3_SHIFT) +#define ADC_JSQR_JSQ3(x) (((uint32_t)(((uint32_t)(x)) << ADC_JSQR_JSQ3_SHIFT)) & ADC_JSQR_JSQ3_MASK) + +#define ADC_JSQR_JSQ2_SHIFT (10) +#define ADC_JSQR_JSQ2_MASK (0x1FU << ADC_JSQR_JSQ2_SHIFT) +#define ADC_JSQR_JSQ2(x) (((uint32_t)(((uint32_t)(x)) << ADC_JSQR_JSQ2_SHIFT)) & ADC_JSQR_JSQ2_MASK) + +#define ADC_JSQR_JSQ1_SHIFT (5) +#define ADC_JSQR_JSQ1_MASK (0x1FU << ADC_JSQR_JSQ1_SHIFT) +#define ADC_JSQR_JSQ1(x) (((uint32_t)(((uint32_t)(x)) << ADC_JSQR_JSQ1_SHIFT)) & ADC_JSQR_JSQ1_MASK) + +#define ADC_JSQR_JSQ0_SHIFT (0) +#define ADC_JSQR_JSQ0_MASK (0x1FU << ADC_JSQR_JSQ0_SHIFT) +#define ADC_JSQR_JSQ0(x) (((uint32_t)(((uint32_t)(x)) << ADC_JSQR_JSQ0_SHIFT)) & ADC_JSQR_JSQ0_MASK) + +/*! + * @brief ADC_JADDATA Register Bit Definition + */ + +#define ADC_JADDATA_JVALID_SHIFT (22) +#define ADC_JADDATA_JVALID_MASK (0x01U << ADC_JADDATA_JVALID_SHIFT) +#define ADC_JADDATA_JVALID(x) (((uint32_t)(((uint32_t)(x)) << ADC_JADDATA_JVALID_SHIFT)) & ADC_JADDATA_JVALID_MASK) + +#define ADC_JADDATA_JOVERRUN_SHIFT (21) +#define ADC_JADDATA_JOVERRUN_MASK (0x01U << ADC_JADDATA_JOVERRUN_SHIFT) +#define ADC_JADDATA_JOVERRUN(x) (((uint32_t)(((uint32_t)(x)) << ADC_JADDATA_JOVERRUN_SHIFT)) & ADC_JADDATA_JOVERRUN_MASK) + +#define ADC_JADDATA_JCHANNELSEL_SHIFT (16) +#define ADC_JADDATA_JCHANNELSEL_MASK (0xFU << ADC_JADDATA_JCHANNELSEL_SHIFT) +#define ADC_JADDATA_JCHANNELSEL(x) (((uint32_t)(((uint32_t)(x)) << ADC_JADDATA_JCHANNELSEL_SHIFT)) & ADC_JADDATA_JCHANNELSEL_MASK) + +#define ADC_JADDATA_JDATA_SHIFT (0) +#define ADC_JADDATA_JDATA_MASK (0xFFFFU << ADC_JADDATA_JDATA_SHIFT) +#define ADC_JADDATA_JDATA(x) (((uint32_t)(((uint32_t)(x)) << ADC_JADDATA_JDATA_SHIFT)) & ADC_JADDATA_JDATA_MASK) + +/*! + * @brief ADC_JDR Register Bit Definition + */ + +#define ADC_JDR_JVALID_SHIFT (22) +#define ADC_JDR_JVALID_MASK (0x01U << ADC_JDR_JVALID_SHIFT) +#define ADC_JDR_JVALID(x) (((uint32_t)(((uint32_t)(x)) << ADC_JDR_JVALID_SHIFT)) & ADC_JDR_JVALID_MASK) + +#define ADC_JDR_JOVERRUN_SHIFT (21) +#define ADC_JDR_JOVERRUN_MASK (0x01U << ADC_JDR_JOVERRUN_SHIFT) +#define ADC_JDR_JOVERRUN(x) (((uint32_t)(((uint32_t)(x)) << ADC_JDR_JOVERRUN_SHIFT)) & ADC_JDR_JOVERRUN_MASK) + +#define ADC_JDR_JDATA_SHIFT (0) +#define ADC_JDR_JDATA_MASK (0xFFFFU << ADC_JDR_JDATA_SHIFT) +#define ADC_JDR_JDATA(x) (((uint32_t)(((uint32_t)(x)) << ADC_JDR_JDATA_SHIFT)) & ADC_JDR_JDATA_MASK) + +/*! + * @} + */ /* end of group ADC_Register_Masks */ +/****************************************************************************** + * ADC Instance +******************************************************************************/ +#define ADC1 ((ADC_Type*)ADC1_BASE) +#define ADC2 ((ADC_Type*)ADC2_BASE) +#define ADC3 ((ADC_Type*)ADC3_BASE) + +/*! + * @} + */ /* end of group ADC_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup DAC_Peripheral_Access_Layer DAC Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * DAC Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR; ///< DAC control register offset: 0x00 + __IO uint32_t SWTRIGR; ///< DAC software trigger register offset: 0x04 + __IO uint32_t DHR12R1; ///< 12-bit right-justified data holding register for DAC channel 1 offset: 0x08 + __IO uint32_t DHR12L1; ///< DAC channel 1 12-bit left-justified data holding register offset: 0x0C + __IO uint32_t DHR8R1; ///< 8-bit right-justified data holding register for DAC channel 1 offset: 0x10 + __IO uint32_t DHR12R2; ///< 12-bit right-justified data holding register for DAC channel 2 offset: 0x14 + __IO uint32_t DHR12L2; ///< 12-bit left-justified data holding register for DAC channel 2 offset: 0x18 + __IO uint32_t DHR8R2; ///< 8-bit right-justified data holding register for DAC channel 2 offset: 0x1C + __IO uint32_t DHR12RD; ///< 12-bit right-justified data holding register for dual DAC offset: 0x20 + __IO uint32_t DHR12LD; ///< 12-bit left-justified data holding register for dual DAC offset: 0x24 + __IO uint32_t DHR8RD; ///< 8-bit right-justified data holding register for dual DAC offset: 0x28 + __IO uint32_t DOR1; ///< DAC channel 1 data output register offset: 0x2C + __IO uint32_t DOR2; ///< DAC channel 2 data output register offset: 0x30 +} DAC_Type; + +/******************************************************************************* + * DAC Type + ******************************************************************************/ + +/*! + * @addtogroup DAC_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief DAC_CR Register Bit Definition + */ + +#define DAC_CR_DMAEN2_SHIFT (28) +#define DAC_CR_DMAEN2_MASK (0x01U << DAC_CR_DMAEN2_SHIFT) +#define DAC_CR_DMAEN2(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_DMAEN2_SHIFT)) & DAC_CR_DMAEN2_MASK) + +#define DAC_CR_MAMP2_SHIFT (24) +#define DAC_CR_MAMP2_MASK (0xFU << DAC_CR_MAMP2_SHIFT) +#define DAC_CR_MAMP2(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_MAMP2_SHIFT)) & DAC_CR_MAMP2_MASK) + +#define DAC_CR_WAVE2_SHIFT (22) +#define DAC_CR_WAVE2_MASK (0x03U << DAC_CR_WAVE2_SHIFT) +#define DAC_CR_WAVE2(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_WAVE2_SHIFT)) & DAC_CR_WAVE2_MASK) + +#define DAC_CR_TSEL2_SHIFT (19) +#define DAC_CR_TSEL2_MASK (0x07U << DAC_CR_TSEL2_SHIFT) +#define DAC_CR_TSEL2(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_TSEL2_SHIFT)) & DAC_CR_TSEL2_MASK) + +#define DAC_CR_TEN2_SHIFT (18) +#define DAC_CR_TEN2_MASK (0x01U << DAC_CR_TEN2_SHIFT) +#define DAC_CR_TEN2(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_TEN2_SHIFT)) & DAC_CR_TEN2_MASK) + +#define DAC_CR_BOFF2_SHIFT (17) +#define DAC_CR_BOFF2_MASK (0x01U << DAC_CR_BOFF2_SHIFT) +#define DAC_CR_BOFF2(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_BOFF2_SHIFT)) & DAC_CR_BOFF2_MASK) + +#define DAC_CR_EN2_SHIFT (16) +#define DAC_CR_EN2_MASK (0x01U << DAC_CR_EN2_SHIFT) +#define DAC_CR_EN2(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_EN2_SHIFT)) & DAC_CR_EN2_MASK) + +#define DAC_CR_DMAEN1_SHIFT (12) +#define DAC_CR_DMAEN1_MASK (0x01U << DAC_CR_DMAEN1_SHIFT) +#define DAC_CR_DMAEN1(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_DMAEN1_SHIFT)) & DAC_CR_DMAEN1_MASK) + +#define DAC_CR_MAMP1_SHIFT (8) +#define DAC_CR_MAMP1_MASK (0xFU << DAC_CR_MAMP1_SHIFT) +#define DAC_CR_MAMP1(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_MAMP1_SHIFT)) & DAC_CR_MAMP1_MASK) + +#define DAC_CR_WAVE1_SHIFT (6) +#define DAC_CR_WAVE1_MASK (0x3U << DAC_CR_WAVE1_SHIFT) +#define DAC_CR_WAVE1(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_WAVE1_SHIFT)) & DAC_CR_WAVE1_MASK) + +#define DAC_CR_TSEL1_SHIFT (3) +#define DAC_CR_TSEL1_MASK (0x7U << DAC_CR_TSEL1_SHIFT) +#define DAC_CR_TSEL1(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_TSEL1_SHIFT)) & DAC_CR_TSEL1_MASK) + +#define DAC_CR_TEN1_SHIFT (2) +#define DAC_CR_TEN1_MASK (0x01U << DAC_CR_TEN1_SHIFT) +#define DAC_CR_TEN1(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_TEN1_SHIFT)) & DAC_CR_TEN1_MASK) + +#define DAC_CR_BOFF1_SHIFT (1) +#define DAC_CR_BOFF1_MASK (0x01U << DAC_CR_BOFF1_SHIFT) +#define DAC_CR_BOFF1(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_BOFF1_SHIFT)) & DAC_CR_BOFF1_MASK) + +#define DAC_CR_EN1_SHIFT (0) +#define DAC_CR_EN1_MASK (0x01U << DAC_CR_EN1_SHIFT) +#define DAC_CR_EN1(x) (((uint32_t)(((uint32_t)(x)) << DAC_CR_EN1_SHIFT)) & DAC_CR_EN1_MASK) + +/*! + * @brief DAC_SWTRIGR Register Bit Definition + */ + +#define DAC_SWTRIGR_DACPRE_SHIFT (8) +#define DAC_SWTRIGR_DACPRE_MASK (0x7FU << DAC_SWTRIGR_DACPRE_SHIFT) +#define DAC_SWTRIGR_DACPRE(x) (((uint32_t)(((uint32_t)(x)) << DAC_SWTRIGR_DACPRE_SHIFT)) & DAC_SWTRIGR_DACPRE_MASK) + +#define DAC_SWTRIGR_SWTRIG2_SHIFT (1) +#define DAC_SWTRIGR_SWTRIG2_MASK (0x01U << DAC_SWTRIGR_SWTRIG2_SHIFT) +#define DAC_SWTRIGR_SWTRIG2(x) (((uint32_t)(((uint32_t)(x)) << DAC_SWTRIGR_SWTRIG2_SHIFT)) & DAC_SWTRIGR_SWTRIG2_MASK) + +#define DAC_SWTRIGR_SWTRIG1_SHIFT (0) +#define DAC_SWTRIGR_SWTRIG1_MASK (0x01U << DAC_SWTRIGR_SWTRIG1_SHIFT) +#define DAC_SWTRIGR_SWTRIG1(x) (((uint32_t)(((uint32_t)(x)) << DAC_SWTRIGR_SWTRIG1_SHIFT)) & DAC_SWTRIGR_SWTRIG1_MASK) + +/*! + * @brief DAC_DHR12R1 Register Bit Definition + */ + +#define DAC_DHR12R1_DACC1DHR_SHIFT (0) +#define DAC_DHR12R1_DACC1DHR_MASK (0xFFFU << DAC_DHR12R1_DACC1DHR_SHIFT) +#define DAC_DHR12R1_DACC1DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12R1_DACC1DHR_SHIFT)) & DAC_DHR12R1_DACC1DHR_MASK) + +/*! + * @brief DAC_DHR12L1 Register Bit Definition + */ + +#define DAC_DHR12L1_DACC1DHR_SHIFT (4) +#define DAC_DHR12L1_DACC1DHR_MASK (0xFFFU << DAC_DHR12L1_DACC1DHR_SHIFT) +#define DAC_DHR12L1_DACC1DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12L1_DACC1DHR_SHIFT)) & DAC_DHR12L1_DACC1DHR_MASK) + +/*! + * @brief DAC_DHR8R1 Register Bit Definition + */ + +#define DAC_DHR8R1_DACC1DHR_SHIFT (0) +#define DAC_DHR8R1_DACC1DHR_MASK (0xFFU << DAC_DHR8R1_DACC1DHR_SHIFT) +#define DAC_DHR8R1_DACC1DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR8R1_DACC1DHR_SHIFT)) & DAC_DHR8R1_DACC1DHR_MASK) + +/*! + * @brief DAC_DHR12R2 Register Bit Definition + */ + +#define DAC_DHR12R2_DACC2DHR_SHIFT (0) +#define DAC_DHR12R2_DACC2DHR_MASK (0xFFFU << DAC_DHR12R2_DACC2DHR_SHIFT) +#define DAC_DHR12R2_DACC2DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12R2_DACC2DHR_SHIFT)) & DAC_DHR12R2_DACC2DHR_MASK) + +/*! + * @brief DAC_DHR12L2 Register Bit Definition + */ + +#define DAC_DHR12L2_DACC2DHR_SHIFT (4) +#define DAC_DHR12L2_DACC2DHR_MASK (0xFFFU << DAC_DHR12L2_DACC2DHR_SHIFT) +#define DAC_DHR12L2_DACC2DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12L2_DACC2DHR_SHIFT)) & DAC_DHR12L2_DACC2DHR_MASK) + +/*! + * @brief DAC_DHR8R2 Register Bit Definition + */ + +#define DAC_DHR8R2_DACC2DHR_SHIFT (0) +#define DAC_DHR8R2_DACC2DHR_MASK (0xFFU << DAC_DHR8R2_DACC2DHR_SHIFT) +#define DAC_DHR8R2_DACC2DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR8R2_DACC2DHR_SHIFT)) & DAC_DHR8R2_DACC2DHR_MASK) + +/*! + * @brief DAC_DHR12RD Register Bit Definition + */ + +#define DAC_DHR12RD_DACC2DHR_SHIFT (16) +#define DAC_DHR12RD_DACC2DHR_MASK (0xFFFU << DAC_DHR12RD_DACC2DHR_SHIFT) +#define DAC_DHR12RD_DACC2DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12RD_DACC2DHR_SHIFT)) & DAC_DHR12RD_DACC2DHR_MASK) + +#define DAC_DHR12RD_DACC1DHR_SHIFT (0) +#define DAC_DHR12RD_DACC1DHR_MASK (0xFFFU << DAC_DHR12RD_DACC1DHR_SHIFT) +#define DAC_DHR12RD_DACC1DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12RD_DACC1DHR_SHIFT)) & DAC_DHR12RD_DACC1DHR_MASK) + +/*! + * @brief DAC_DHR12LD Register Bit Definition + */ + +#define DAC_DHR12LD_DACC2DHR_SHIFT (20) +#define DAC_DHR12LD_DACC2DHR_MASK (0xFFFU << DAC_DHR12LD_DACC2DHR_SHIFT) +#define DAC_DHR12LD_DACC2DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12LD_DACC2DHR_SHIFT)) & DAC_DHR12LD_DACC2DHR_MASK) + +#define DAC_DHR12LD_DACC1DHR_SHIFT (4) +#define DAC_DHR12LD_DACC1DHR_MASK (0xFFFU << DAC_DHR12LD_DACC1DHR_SHIFT) +#define DAC_DHR12LD_DACC1DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR12LD_DACC1DHR_SHIFT)) & DAC_DHR12LD_DACC1DHR_MASK) + +/*! + * @brief DAC_DHR8RD Register Bit Definition + */ + +#define DAC_DHR8RD_DACC2DHR_SHIFT (8) +#define DAC_DHR8RD_DACC2DHR_MASK (0xFFU << DAC_DHR8RD_DACC2DHR_SHIFT) +#define DAC_DHR8RD_DACC2DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR8RD_DACC2DHR_SHIFT)) & DAC_DHR8RD_DACC2DHR_MASK) + +#define DAC_DHR8RD_DACC1DHR_SHIFT (0) +#define DAC_DHR8RD_DACC1DHR_MASK (0xFFU << DAC_DHR8RD_DACC1DHR_SHIFT) +#define DAC_DHR8RD_DACC1DHR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DHR8RD_DACC1DHR_SHIFT)) & DAC_DHR8RD_DACC1DHR_MASK) + +/*! + * @brief DAC_DOR1 Register Bit Definition + */ + +#define DAC_DOR1_DACC1DOR_SHIFT (0) +#define DAC_DOR1_DACC1DOR_MASK (0xFFFU << DAC_DOR1_DACC1DOR_SHIFT) +#define DAC_DOR1_DACC1DOR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DOR1_DACC1DOR_SHIFT)) & DAC_DOR1_DACC1DOR_MASK) + +/*! + * @brief DAC_DOR2 Register Bit Definition + */ + +#define DAC_DOR2_DACC2DOR_SHIFT (0) +#define DAC_DOR2_DACC2DOR_MASK (0xFFFU << DAC_DOR2_DACC2DOR_SHIFT) +#define DAC_DOR2_DACC2DOR(x) (((uint32_t)(((uint32_t)(x)) << DAC_DOR2_DACC2DOR_SHIFT)) & DAC_DOR2_DACC2DOR_MASK) + +/*! + * @} + */ /* end of group DAC_Register_Masks */ +/****************************************************************************** + * DAC Instance +******************************************************************************/ +#define DAC ((DAC_Type*)DAC_BASE) + +/*! + * @} + */ /* end of group DAC_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup COMP_Peripheral_Access_Layer COMP Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * COMP Type + ******************************************************************************/ +typedef struct { + __IO uint32_t Reserved45a[3]; ///< Reserved + __IO uint32_t CSR[2]; ///< Comparator x (x=1, 2) control and status registeroffset: 0x0C + __IO uint32_t Reserved45[1]; ///< Reserved + __IO uint32_t CRV; ///< Comparator external reference voltage registeroffset: 0x18 + __IO uint32_t POLL[2]; ///< Comparator x (x=1, 2) polling register offset: 0x1C +} COMP_Type; + +/******************************************************************************* + * COMP Type + ******************************************************************************/ + +/*! + * @addtogroup COMP_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief COMP_CSR Register Bit Definition + */ + +#define COMP_CSR_LOCK_SHIFT (31) +#define COMP_CSR_LOCK_MASK (0x01U << COMP_CSR_LOCK_SHIFT) +#define COMP_CSR_LOCK(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_LOCK_SHIFT)) & COMP_CSR_LOCK_MASK) + +#define COMP_CSR_OUT_SHIFT (30) +#define COMP_CSR_OUT_MASK (0x01U << COMP_CSR_OUT_SHIFT) +#define COMP_CSR_OUT(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_OUT_SHIFT)) & COMP_CSR_OUT_MASK) + +#define COMP_CSR_OFLT_SHIFT (18) +#define COMP_CSR_OFLT_MASK (0x7U << COMP_CSR_OFLT_SHIFT) +#define COMP_CSR_OFLT(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_OFLT_SHIFT)) & COMP_CSR_OFLT_MASK) + +#define COMP_CSR_HYST_SHIFT (16) +#define COMP_CSR_HYST_MASK (0x3U << COMP_CSR_HYST_SHIFT) +#define COMP_CSR_HYST(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_HYST_SHIFT)) & COMP_CSR_HYST_MASK) + +#define COMP_CSR_POL_SHIFT (15) +#define COMP_CSR_POL_MASK (0x01U << COMP_CSR_POL_SHIFT) +#define COMP_CSR_POL(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_POL_SHIFT)) & COMP_CSR_POL_MASK) + +#define COMP_CSR_OUTSEL_SHIFT (10) +#define COMP_CSR_OUTSEL_MASK (0xFU << COMP_CSR_OUTSEL_SHIFT) +#define COMP_CSR_OUTSEL(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_OUTSEL_SHIFT)) & COMP_CSR_OUTSEL_MASK) + +#define COMP_CSR_INPSEL_SHIFT (7) +#define COMP_CSR_INPSEL_MASK (0x3U << COMP_CSR_INPSEL_SHIFT) +#define COMP_CSR_INPSEL(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_INPSEL_SHIFT)) & COMP_CSR_INPSEL_MASK) + +#define COMP_CSR_INMSEL_SHIFT (4) +#define COMP_CSR_INMSEL_MASK (0x3U << COMP_CSR_INMSEL_SHIFT) +#define COMP_CSR_INMSEL(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_INMSEL_SHIFT)) & COMP_CSR_INMSEL_MASK) + +#define COMP_CSR_MODE_SHIFT (2) +#define COMP_CSR_MODE_MASK (0x3U << COMP_CSR_MODE_SHIFT) +#define COMP_CSR_MODE(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_MODE_SHIFT)) & COMP_CSR_MODE_MASK) + +#define COMP_CSR_EN_SHIFT (0) +#define COMP_CSR_EN_MASK (0x01U << COMP_CSR_EN_SHIFT) +#define COMP_CSR_EN(x) (((uint32_t)(((uint32_t)(x)) << COMP_CSR_EN_SHIFT)) & COMP_CSR_EN_MASK) + +/*! + * @brief COMP_CRV Register Bit Definition + */ + +#define COMP_CRV_CRVSRC_SHIFT (5) +#define COMP_CRV_CRVSRC_MASK (0x01U << COMP_CRV_CRVSRC_SHIFT) +#define COMP_CRV_CRVSRC(x) (((uint32_t)(((uint32_t)(x)) << COMP_CRV_CRVSRC_SHIFT)) & COMP_CRV_CRVSRC_MASK) + +#define COMP_CRV_CRVEN_SHIFT (4) +#define COMP_CRV_CRVEN_MASK (0x01U << COMP_CRV_CRVEN_SHIFT) +#define COMP_CRV_CRVEN(x) (((uint32_t)(((uint32_t)(x)) << COMP_CRV_CRVEN_SHIFT)) & COMP_CRV_CRVEN_MASK) + +#define COMP_CRV_CRVSEL_SHIFT (0) +#define COMP_CRV_CRVSEL_MASK (0xFU << COMP_CRV_CRVSEL_SHIFT) +#define COMP_CRV_CRVSEL(x) (((uint32_t)(((uint32_t)(x)) << COMP_CRV_CRVSEL_SHIFT)) & COMP_CRV_CRVSEL_MASK) + +/*! + * @brief COMP_POLL Register Bit Definition + */ + +#define COMP_POLL_POUT_SHIFT (8) +#define COMP_POLL_POUT_MASK (0x7U << COMP_POLL_POUT_SHIFT) +#define COMP_POLL_POUT(x) (((uint32_t)(((uint32_t)(x)) << COMP_POLL_POUT_SHIFT)) & COMP_POLL_POUT_MASK) + +#define COMP_POLL_PERIOD_SHIFT (4) +#define COMP_POLL_PERIOD_MASK (0x7U << COMP_POLL_PERIOD_SHIFT) +#define COMP_POLL_PERIOD(x) (((uint32_t)(((uint32_t)(x)) << COMP_POLL_PERIOD_SHIFT)) & COMP_POLL_PERIOD_MASK) + +#define COMP_POLL_FIXN_SHIFT (2) +#define COMP_POLL_FIXN_MASK (0x01U << COMP_POLL_FIXN_SHIFT) +#define COMP_POLL_FIXN(x) (((uint32_t)(((uint32_t)(x)) << COMP_POLL_FIXN_SHIFT)) & COMP_POLL_FIXN_MASK) + +#define COMP_POLL_POLLCH_SHIFT (1) +#define COMP_POLL_POLLCH_MASK (0x01U << COMP_POLL_POLLCH_SHIFT) +#define COMP_POLL_POLLCH(x) (((uint32_t)(((uint32_t)(x)) << COMP_POLL_POLLCH_SHIFT)) & COMP_POLL_POLLCH_MASK) + +#define COMP_POLL_POLLEN_SHIFT (0) +#define COMP_POLL_POLLEN_MASK (0x01U << COMP_POLL_POLLEN_SHIFT) +#define COMP_POLL_POLLEN(x) (((uint32_t)(((uint32_t)(x)) << COMP_POLL_POLLEN_SHIFT)) & COMP_POLL_POLLEN_MASK) + +/*! + * @} + */ /* end of group COMP_Register_Masks */ +/****************************************************************************** + * COMP Instance +******************************************************************************/ +#define COMP ((COMP_Type*)COMP_BASE) + +/*! + * @} + */ /* end of group COMP_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup CRC_Peripheral_Access_Layer CRC Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * CRC Type + ******************************************************************************/ +typedef struct { + __IO uint32_t DR; ///< CRC data register offset: 0x00 + __IO uint32_t IDR; ///< CRC independent data register offset: 0x04 + __IO uint32_t CTRL; ///< CRC control register offset: 0x08 + __IO uint32_t MIR; ///< CRC intermediate data register offset: 0x0C +} CRC_Type; + +/******************************************************************************* + * CRC Type + ******************************************************************************/ + +/*! + * @addtogroup CRC_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief CRC_DR Register Bit Definition + */ + +#define CRC_DR_DR_SHIFT (0) +#define CRC_DR_DR_MASK (0xFFFFFFFFU << CRC_DR_DR_SHIFT) +#define CRC_DR_DR(x) (((uint32_t)(((uint32_t)(x)) << CRC_DR_DR_SHIFT)) & CRC_DR_DR_MASK) + +/*! + * @brief CRC_IDR Register Bit Definition + */ + +#define CRC_IDR_IDR_SHIFT (0) +#define CRC_IDR_IDR_MASK (0xFFU << CRC_IDR_IDR_SHIFT) +#define CRC_IDR_IDR(x) (((uint32_t)(((uint32_t)(x)) << CRC_IDR_IDR_SHIFT)) & CRC_IDR_IDR_MASK) + +/*! + * @brief CRC_CTRL Register Bit Definition + */ + +#define CRC_CTRL_BIGEO_SHIFT (5) +#define CRC_CTRL_BIGEO_MASK (0x01U << CRC_CTRL_BIGEO_SHIFT) +#define CRC_CTRL_BIGEO(x) (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_BIGEO_SHIFT)) & CRC_CTRL_BIGEO_MASK) + +#define CRC_CTRL_BIGEI_SHIFT (4) +#define CRC_CTRL_BIGEI_MASK (0x01U << CRC_CTRL_BIGEI_SHIFT) +#define CRC_CTRL_BIGEI(x) (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_BIGEI_SHIFT)) & CRC_CTRL_BIGEI_MASK) + +#define CRC_CTRL_CRCBITSEL_SHIFT (2) +#define CRC_CTRL_CRCBITSEL_MASK (0x3U << CRC_CTRL_CRCBITSEL_SHIFT) +#define CRC_CTRL_CRCBITSEL(x) (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_CRCBITSEL_SHIFT)) & CRC_CTRL_CRCBITSEL_MASK) + +#define CRC_CTRL_POLY32MGN_SHIFT (1) +#define CRC_CTRL_POLY32MGN_MASK (0x01U << CRC_CTRL_POLY32MGN_SHIFT) +#define CRC_CTRL_POLY32MGN(x) (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_POLY32MGN_SHIFT)) & CRC_CTRL_POLY32MGN_MASK) + +#define CRC_CTRL_RESET_SHIFT (0) +#define CRC_CTRL_RESET_MASK (0x01U << CRC_CTRL_RESET_SHIFT) +#define CRC_CTRL_RESET(x) (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_RESET_SHIFT)) & CRC_CTRL_RESET_MASK) + +/*! + * @brief CRC_MIR Register Bit Definition + */ + +#define CRC_MIR_CRCMIR_SHIFT (0) +#define CRC_MIR_CRCMIR_MASK (0xFFFFFFFFU << CRC_MIR_CRCMIR_SHIFT) +#define CRC_MIR_CRCMIR(x) (((uint32_t)(((uint32_t)(x)) << CRC_MIR_CRCMIR_SHIFT)) & CRC_MIR_CRCMIR_MASK) + +/*! + * @} + */ /* end of group CRC_Register_Masks */ +/****************************************************************************** + * CRC Instance +******************************************************************************/ +#define CRC ((CRC_Type*)CRC_BASE) + +/*! + * @} + */ /* end of group CRC_Peripheral_Access_Layer */ + + + +/*! + * @addtogroup DEBUG_Peripheral_Access_Layer DEBUG Peripheral Access Layer + * @{ + */ + +/******************************************************************************* + * DEBUG Type + ******************************************************************************/ +typedef struct { + __IO uint32_t CR; ///< DEBUG control register offset: 0x00 +} DBG_Type; + +/******************************************************************************* + * DEBUG Type + ******************************************************************************/ + +/*! + * @addtogroup DEBUG_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief DBG_CR Register Bit Definition + */ + +#define DBG_CR_DEBUGTIM8STOP_SHIFT (17) +#define DBG_CR_DEBUGTIM8STOP_MASK (0xFU << DBG_CR_DEBUGTIM8STOP_SHIFT) +#define DBG_CR_DEBUGTIM8STOP(x) (((uint32_t)(((uint32_t)(x)) << DBG_CR_DEBUGTIM8STOP_SHIFT)) & DBG_CR_DEBUGTIMXSTOP_MASK) + +#define DBG_CR_DEBUGTIM1STOP_SHIFT (10) +#define DBG_CR_DEBUGTIM1STOP_MASK (0xFU << DBG_CR_DEBUGTIM1STOP_SHIFT) +#define DBG_CR_DEBUGTIM1STOP(x) (((uint32_t)(((uint32_t)(x)) << DBG_CR_DEBUGTIM1STOP_SHIFT)) & DBG_CR_DEBUGTIMXSTOP_MASK) + +#define DBG_CR_DEBUGWWDGSTOP_SHIFT (9) +#define DBG_CR_DEBUGWWDGSTOP_MASK (0x01U << DBG_CR_DEBUGWWDGSTOP_SHIFT) +#define DBG_CR_DEBUGWWDGSTOP(x) (((uint32_t)(((uint32_t)(x)) << DBG_CR_DEBUGWWDGSTOP_SHIFT)) & DBG_CR_DEBUGWWDGSTOP_MASK) + +#define DBG_CR_DEBUGIWDGSTOP_SHIFT (8) +#define DBG_CR_DEBUGIWDGSTOP_MASK (0x01U << DBG_CR_DEBUGIWDGSTOP_SHIFT) +#define DBG_CR_DEBUGIWDGSTOP(x) (((uint32_t)(((uint32_t)(x)) << DBG_CR_DEBUGIWDGSTOP_SHIFT)) & DBG_CR_DEBUGIWDGSTOP_MASK) + +#define DBG_CR_DEBUGSTOPFORLDO_SHIFT (3) +#define DBG_CR_DEBUGSTOPFORLDO_MASK (0x01U << DBG_CR_DEBUGSTOPFORLDO_SHIFT) +#define DBG_CR_DEBUGSTOPFORLDO(x) (((uint32_t)(((uint32_t)(x)) << DBG_CR_DEBUGSTOPFORLDO_SHIFT)) & DBG_CR_DEBUGSTOPFORLDO_MASK) + +/*! + * @} + */ /* end of group DEBUG_Register_Masks */ +/****************************************************************************** + * DEBUG Instance +******************************************************************************/ +#define DBG ((DBG_Type*)DBG_BASE) + +/*! + * @} + */ /* end of group DEBUG_Peripheral_Access_Layer */ + + + + +/* +** End of section using anonymous unions +*/ + +#if defined(__ARMCC_VERSION) + #if (__ARMCC_VERSION >= 6010050) + #pragma clang diagnostic pop + #else + #pragma pop + #endif +#elif defined(__GNUC__) + /* leave anonymous unions enabled */ +#elif defined(__IAR_SYSTEMS_ICC__) + #pragma language=default +#else + #error Not supported compiler type +#endif + +/*! + * @} + */ /* end of group Peripheral_access_layer */ + +#endif /* __MM32F3277G_H__ */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g_features.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g_features.h new file mode 100644 index 0000000000..cc008a78be --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/mm32f3277g_features.h @@ -0,0 +1,1837 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#ifndef __MM32F3277G_FEATURES_H__ +#define __MM32F3277G_FEATURES_H__ + +#include "mm32f3277g.h" + +/*! + * @brief TIM_ADV_Type. + */ +#define TIM_ADV_Type TIM1_Type /*!< TIM ADV Module Register set referring to TIM1. */ + +/*! + * @brief TIM_16B_Type. + */ +#define TIM_16B_Type TIM3_Type /*!< TIM 16B Module Register set referring to TIM3. */ + +/*! + * @brief TIM_32B_Type. + */ +#define TIM_32B_Type TIM2_Type /*!< TIM 32B Module Register set referring to TIM2. */ + +/*! + * @brief TIM_BASIC_Type. + */ +#define TIM_BASIC_Type TIM6_Type /*!< TIM BASIC Module Register set referring to TIM6. */ + +/******************************************************************************* + * TIM_ADV Type + ******************************************************************************/ + +/*! + * @addtogroup TIM_ADV_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM_ADV_CR1 Register Bit Definition + */ + +#define TIM_ADV_CR1_CKD_SHIFT TIM1_CR1_CKD_SHIFT +#define TIM_ADV_CR1_CKD_MASK TIM1_CR1_CKD_MASK +#define TIM_ADV_CR1_CKD(x) TIM1_CR1_CKD(x) + +#define TIM_ADV_CR1_APRE_SHIFT TIM1_CR1_APRE_SHIFT +#define TIM_ADV_CR1_APRE_MASK TIM1_CR1_APRE_MASK +#define TIM_ADV_CR1_APRE(x) TIM1_CR1_APRE(x) + +#define TIM_ADV_CR1_CMS_SHIFT TIM1_CR1_CMS_SHIFT +#define TIM_ADV_CR1_CMS_MASK TIM1_CR1_CMS_MASK +#define TIM_ADV_CR1_CMS(x) TIM1_CR1_CMS(x) + +#define TIM_ADV_CR1_DIR_SHIFT TIM1_CR1_DIR_SHIFT +#define TIM_ADV_CR1_DIR_MASK TIM1_CR1_DIR_MASK +#define TIM_ADV_CR1_DIR(x) TIM1_CR1_DIR(x) + +#define TIM_ADV_CR1_OPM_SHIFT TIM1_CR1_OPM_SHIFT +#define TIM_ADV_CR1_OPM_MASK TIM1_CR1_OPM_MASK +#define TIM_ADV_CR1_OPM(x) TIM1_CR1_OPM(x) + +#define TIM_ADV_CR1_URS_SHIFT TIM1_CR1_URS_SHIFT +#define TIM_ADV_CR1_URS_MASK TIM1_CR1_URS_MASK +#define TIM_ADV_CR1_URS(x) TIM1_CR1_URS(x) + +#define TIM_ADV_CR1_UDIS_SHIFT TIM1_CR1_UDIS_SHIFT +#define TIM_ADV_CR1_UDIS_MASK TIM1_CR1_UDIS_MASK +#define TIM_ADV_CR1_UDIS(x) TIM1_CR1_UDIS(x) + +#define TIM_ADV_CR1_CEN_SHIFT TIM1_CR1_CEN_SHIFT +#define TIM_ADV_CR1_CEN_MASK TIM1_CR1_CEN_MASK +#define TIM_ADV_CR1_CEN(x) TIM1_CR1_CEN(x) + +/*! + * @brief TIM_ADV_CR2 Register Bit Definition + */ + +#define TIM_ADV_CR2_OIS4_SHIFT TIM1_CR2_OIS4_SHIFT +#define TIM_ADV_CR2_OIS4_MASK TIM1_CR2_OIS4_MASK +#define TIM_ADV_CR2_OIS4(x) TIM1_CR2_OIS4(x) + +#define TIM_ADV_CR2_OIS3N_SHIFT TIM1_CR2_OIS3N_SHIFT +#define TIM_ADV_CR2_OIS3N_MASK TIM1_CR2_OIS3N_MASK +#define TIM_ADV_CR2_OIS3N(x) TIM1_CR2_OIS3N(x) + +#define TIM_ADV_CR2_OIS3_SHIFT TIM1_CR2_OIS3_SHIFT +#define TIM_ADV_CR2_OIS3_MASK TIM1_CR2_OIS3_MASK +#define TIM_ADV_CR2_OIS3(x) TIM1_CR2_OIS3(x) + +#define TIM_ADV_CR2_OIS2N_SHIFT TIM1_CR2_OIS2N_SHIFT +#define TIM_ADV_CR2_OIS2N_MASK TIM1_CR2_OIS2N_MASK +#define TIM_ADV_CR2_OIS2N(x) TIM1_CR2_OIS2N(x) + +#define TIM_ADV_CR2_OIS2_SHIFT TIM1_CR2_OIS2_SHIFT +#define TIM_ADV_CR2_OIS2_MASK TIM1_CR2_OIS2_MASK +#define TIM_ADV_CR2_OIS2(x) TIM1_CR2_OIS2(x) + +#define TIM_ADV_CR2_OIS1N_SHIFT TIM1_CR2_OIS1N_SHIFT +#define TIM_ADV_CR2_OIS1N_MASK TIM1_CR2_OIS1N_MASK +#define TIM_ADV_CR2_OIS1N(x) TIM1_CR2_OIS1N(x) + +#define TIM_ADV_CR2_OIS1_SHIFT TIM1_CR2_OIS1_SHIFT +#define TIM_ADV_CR2_OIS1_MASK TIM1_CR2_OIS1_MASK +#define TIM_ADV_CR2_OIS1(x) TIM1_CR2_OIS1(x) + +#define TIM_ADV_CR2_TI1S_SHIFT TIM1_CR2_TI1S_SHIFT +#define TIM_ADV_CR2_TI1S_MASK TIM1_CR2_TI1S_MASK +#define TIM_ADV_CR2_TI1S(x) TIM1_CR2_TI1S(x) + +#define TIM_ADV_CR2_MMS_SHIFT TIM1_CR2_MMS_SHIFT +#define TIM_ADV_CR2_MMS_MASK TIM1_CR2_MMS_MASK +#define TIM_ADV_CR2_MMS(x) TIM1_CR2_MMS(x) + +#define TIM_ADV_CR2_CCDS_SHIFT TIM1_CR2_CCDS_SHIFT +#define TIM_ADV_CR2_CCDS_MASK TIM1_CR2_CCDS_MASK +#define TIM_ADV_CR2_CCDS(x) TIM1_CR2_CCDS(x) + +#define TIM_ADV_CR2_CCUS_SHIFT TIM1_CR2_CCUS_SHIFT +#define TIM_ADV_CR2_CCUS_MASK TIM1_CR2_CCUS_MASK +#define TIM_ADV_CR2_CCUS(x) TIM1_CR2_CCUS(x) + +#define TIM_ADV_CR2_CCPC_SHIFT TIM1_CR2_CCPC_SHIFT +#define TIM_ADV_CR2_CCPC_MASK TIM1_CR2_CCPC_MASK +#define TIM_ADV_CR2_CCPC(x) TIM1_CR2_CCPC(x) + +/*! + * @brief TIM_ADV_SMCR Register Bit Definition + */ + +#define TIM_ADV_SMCR_ETP_SHIFT TIM1_SMCR_ETP_SHIFT +#define TIM_ADV_SMCR_ETP_MASK TIM1_SMCR_ETP_MASK +#define TIM_ADV_SMCR_ETP(x) TIM1_SMCR_ETP(x) + +#define TIM_ADV_SMCR_ECE_SHIFT TIM1_SMCR_ECE_SHIFT +#define TIM_ADV_SMCR_ECE_MASK TIM1_SMCR_ECE_MASK +#define TIM_ADV_SMCR_ECE(x) TIM1_SMCR_ECE(x) + +#define TIM_ADV_SMCR_ETPS_SHIFT TIM1_SMCR_ETPS_SHIFT +#define TIM_ADV_SMCR_ETPS_MASK TIM1_SMCR_ETPS_MASK +#define TIM_ADV_SMCR_ETPS(x) TIM1_SMCR_ETPS(x) + +#define TIM_ADV_SMCR_ETF_SHIFT TIM1_SMCR_ETF_SHIFT +#define TIM_ADV_SMCR_ETF_MASK TIM1_SMCR_ETF_MASK +#define TIM_ADV_SMCR_ETF(x) TIM1_SMCR_ETF(x) + +#define TIM_ADV_SMCR_MSM_SHIFT TIM1_SMCR_MSM_SHIFT +#define TIM_ADV_SMCR_MSM_MASK TIM1_SMCR_MSM_MASK +#define TIM_ADV_SMCR_MSM(x) TIM1_SMCR_MSM(x) + +#define TIM_ADV_SMCR_TS_SHIFT TIM1_SMCR_TS_SHIFT +#define TIM_ADV_SMCR_TS_MASK TIM1_SMCR_TS_MASK +#define TIM_ADV_SMCR_TS(x) TIM1_SMCR_TS(x) + +#define TIM_ADV_SMCR_OCCS_SHIFT TIM1_SMCR_OCCS_SHIFT +#define TIM_ADV_SMCR_OCCS_MASK TIM1_SMCR_OCCS_MASK +#define TIM_ADV_SMCR_OCCS(x) TIM1_SMCR_OCCS(x) + +#define TIM_ADV_SMCR_SMS_SHIFT TIM1_SMCR_SMS_SHIFT +#define TIM_ADV_SMCR_SMS_MASK TIM1_SMCR_SMS_MASK +#define TIM_ADV_SMCR_SMS(x) TIM1_SMCR_SMS(x) + +/*! + * @brief TIM_ADV_DIER Register Bit Definition + */ + +#define TIM_ADV_DIER_CC5DE_SHIFT TIM1_DIER_CC5DE_SHIFT +#define TIM_ADV_DIER_CC5DE_MASK TIM1_DIER_CC5DE_MASK +#define TIM_ADV_DIER_CC5DE(x) TIM1_DIER_CC5DE(x) + +#define TIM_ADV_DIER_CC5IE_SHIFT TIM1_DIER_CC5IE_SHIFT +#define TIM_ADV_DIER_CC5IE_MASK TIM1_DIER_CC5IE_MASK +#define TIM_ADV_DIER_CC5IE(x) TIM1_DIER_CC5IE(x) + +#define TIM_ADV_DIER_TDE_SHIFT TIM1_DIER_TDE_SHIFT +#define TIM_ADV_DIER_TDE_MASK TIM1_DIER_TDE_MASK +#define TIM_ADV_DIER_TDE(x) TIM1_DIER_TDE(x) + +#define TIM_ADV_DIER_COMDE_SHIFT TIM1_DIER_COMDE_SHIFT +#define TIM_ADV_DIER_COMDE_MASK TIM1_DIER_COMDE_MASK +#define TIM_ADV_DIER_COMDE(x) TIM1_DIER_COMDE(x) + +#define TIM_ADV_DIER_CC4DE_SHIFT TIM1_DIER_CC4DE_SHIFT +#define TIM_ADV_DIER_CC4DE_MASK TIM1_DIER_CC4DE_MASK +#define TIM_ADV_DIER_CC4DE(x) TIM1_DIER_CC4DE(x) + +#define TIM_ADV_DIER_CC3DE_SHIFT TIM1_DIER_CC3DE_SHIFT +#define TIM_ADV_DIER_CC3DE_MASK TIM1_DIER_CC3DE_MASK +#define TIM_ADV_DIER_CC3DE(x) TIM1_DIER_CC3DE(x) + +#define TIM_ADV_DIER_CC2DE_SHIFT TIM1_DIER_CC2DE_SHIFT +#define TIM_ADV_DIER_CC2DE_MASK TIM1_DIER_CC2DE_MASK +#define TIM_ADV_DIER_CC2DE(x) TIM1_DIER_CC2DE(x) + +#define TIM_ADV_DIER_CC1DE_SHIFT TIM1_DIER_CC1DE_SHIFT +#define TIM_ADV_DIER_CC1DE_MASK TIM1_DIER_CC1DE_MASK +#define TIM_ADV_DIER_CC1DE(x) TIM1_DIER_CC1DE(x) + +#define TIM_ADV_DIER_UDE_SHIFT TIM1_DIER_UDE_SHIFT +#define TIM_ADV_DIER_UDE_MASK TIM1_DIER_UDE_MASK +#define TIM_ADV_DIER_UDE(x) TIM1_DIER_UDE(x) + +#define TIM_ADV_DIER_BIE_SHIFT TIM1_DIER_BIE_SHIFT +#define TIM_ADV_DIER_BIE_MASK TIM1_DIER_BIE_MASK +#define TIM_ADV_DIER_BIE(x) TIM1_DIER_BIE(x) + +#define TIM_ADV_DIER_TIE_SHIFT TIM1_DIER_TIE_SHIFT +#define TIM_ADV_DIER_TIE_MASK TIM1_DIER_TIE_MASK +#define TIM_ADV_DIER_TIE(x) TIM1_DIER_TIE(x) + +#define TIM_ADV_DIER_COMIE_SHIFT TIM1_DIER_COMIE_SHIFT +#define TIM_ADV_DIER_COMIE_MASK TIM1_DIER_COMIE_MASK +#define TIM_ADV_DIER_COMIE(x) TIM1_DIER_COMIE(x) + +#define TIM_ADV_DIER_CC4IE_SHIFT TIM1_DIER_CC4IE_SHIFT +#define TIM_ADV_DIER_CC4IE_MASK TIM1_DIER_CC4IE_MASK +#define TIM_ADV_DIER_CC4IE(x) TIM1_DIER_CC4IE(x) + +#define TIM_ADV_DIER_CC3IE_SHIFT TIM1_DIER_CC3IE_SHIFT +#define TIM_ADV_DIER_CC3IE_MASK TIM1_DIER_CC3IE_MASK +#define TIM_ADV_DIER_CC3IE(x) TIM1_DIER_CC3IE(x) + +#define TIM_ADV_DIER_CC2IE_SHIFT TIM1_DIER_CC2IE_SHIFT +#define TIM_ADV_DIER_CC2IE_MASK TIM1_DIER_CC2IE_MASK +#define TIM_ADV_DIER_CC2IE(x) TIM1_DIER_CC2IE(x) + +#define TIM_ADV_DIER_CC1IE_SHIFT TIM1_DIER_CC1IE_SHIFT +#define TIM_ADV_DIER_CC1IE_MASK TIM1_DIER_CC1IE_MASK +#define TIM_ADV_DIER_CC1IE(x) TIM1_DIER_CC1IE(x) + +#define TIM_ADV_DIER_UIE_SHIFT TIM1_DIER_UIE_SHIFT +#define TIM_ADV_DIER_UIE_MASK TIM1_DIER_UIE_MASK +#define TIM_ADV_DIER_UIE(x) TIM1_DIER_UIE(x) + +/*! + * @brief TIM_ADV_SR Register Bit Definition + */ + +#define TIM_ADV_SR_CC5IF_SHIFT TIM1_SR_CC5IF_SHIFT +#define TIM_ADV_SR_CC5IF_MASK TIM1_SR_CC5IF_MASK +#define TIM_ADV_SR_CC5IF(x) TIM1_SR_CC5IF(x) + +#define TIM_ADV_SR_CC4OF_SHIFT TIM1_SR_CC4OF_SHIFT +#define TIM_ADV_SR_CC4OF_MASK TIM1_SR_CC4OF_MASK +#define TIM_ADV_SR_CC4OF(x) TIM1_SR_CC4OF(x) + +#define TIM_ADV_SR_CC3OF_SHIFT TIM1_SR_CC3OF_SHIFT +#define TIM_ADV_SR_CC3OF_MASK TIM1_SR_CC3OF_MASK +#define TIM_ADV_SR_CC3OF(x) TIM1_SR_CC3OF(x) + +#define TIM_ADV_SR_CC2OF_SHIFT TIM1_SR_CC2OF_SHIFT +#define TIM_ADV_SR_CC2OF_MASK TIM1_SR_CC2OF_MASK +#define TIM_ADV_SR_CC2OF(x) TIM1_SR_CC2OF(x) + +#define TIM_ADV_SR_CC1OF_SHIFT TIM1_SR_CC1OF_SHIFT +#define TIM_ADV_SR_CC1OF_MASK TIM1_SR_CC1OF_MASK +#define TIM_ADV_SR_CC1OF(x) TIM1_SR_CC1OF(x) + +#define TIM_ADV_SR_BIF_SHIFT TIM1_SR_BIF_SHIFT +#define TIM_ADV_SR_BIF_MASK TIM1_SR_BIF_MASK +#define TIM_ADV_SR_BIF(x) TIM1_SR_BIF(x) + +#define TIM_ADV_SR_TIF_SHIFT TIM1_SR_TIF_SHIFT +#define TIM_ADV_SR_TIF_MASK TIM1_SR_TIF_MASK +#define TIM_ADV_SR_TIF(x) TIM1_SR_TIF(x) + +#define TIM_ADV_SR_COMIF_SHIFT TIM1_SR_COMIF_SHIFT +#define TIM_ADV_SR_COMIF_MASK TIM1_SR_COMIF_MASK +#define TIM_ADV_SR_COMIF(x) TIM1_SR_COMIF(x) + +#define TIM_ADV_SR_CC4IF_SHIFT TIM1_SR_CC4IF_SHIFT +#define TIM_ADV_SR_CC4IF_MASK TIM1_SR_CC4IF_MASK +#define TIM_ADV_SR_CC4IF(x) TIM1_SR_CC4IF(x) + +#define TIM_ADV_SR_CC3IF_SHIFT TIM1_SR_CC3IF_SHIFT +#define TIM_ADV_SR_CC3IF_MASK TIM1_SR_CC3IF_MASK +#define TIM_ADV_SR_CC3IF(x) TIM1_SR_CC3IF(x) + +#define TIM_ADV_SR_CC2IF_SHIFT TIM1_SR_CC2IF_SHIFT +#define TIM_ADV_SR_CC2IF_MASK TIM1_SR_CC2IF_MASK +#define TIM_ADV_SR_CC2IF(x) TIM1_SR_CC2IF(x) + +#define TIM_ADV_SR_CC1IF_SHIFT TIM1_SR_CC1IF_SHIFT +#define TIM_ADV_SR_CC1IF_MASK TIM1_SR_CC1IF_MASK +#define TIM_ADV_SR_CC1IF(x) TIM1_SR_CC1IF(x) + +#define TIM_ADV_SR_UIF_SHIFT TIM1_SR_UIF_SHIFT +#define TIM_ADV_SR_UIF_MASK TIM1_SR_UIF_MASK +#define TIM_ADV_SR_UIF(x) TIM1_SR_UIF(x) + +/*! + * @brief TIM_ADV_EGR Register Bit Definition + */ + +#define TIM_ADV_EGR_CC5G_SHIFT TIM1_EGR_CC5G_SHIFT +#define TIM_ADV_EGR_CC5G_MASK TIM1_EGR_CC5G_MASK +#define TIM_ADV_EGR_CC5G(x) TIM1_EGR_CC5G(x) + +#define TIM_ADV_EGR_BG_SHIFT TIM1_EGR_BG_SHIFT +#define TIM_ADV_EGR_BG_MASK TIM1_EGR_BG_MASK +#define TIM_ADV_EGR_BG(x) TIM1_EGR_BG(x) + +#define TIM_ADV_EGR_TG_SHIFT TIM1_EGR_TG_SHIFT +#define TIM_ADV_EGR_TG_MASK TIM1_EGR_TG_MASK +#define TIM_ADV_EGR_TG(x) TIM1_EGR_TG(x) + +#define TIM_ADV_EGR_COMG_SHIFT TIM1_EGR_COMG_SHIFT +#define TIM_ADV_EGR_COMG_MASK TIM1_EGR_COMG_MASK +#define TIM_ADV_EGR_COMG(x) TIM1_EGR_COMG(x) + +#define TIM_ADV_EGR_CC4G_SHIFT TIM1_EGR_CC4G_SHIFT +#define TIM_ADV_EGR_CC4G_MASK TIM1_EGR_CC4G_MASK +#define TIM_ADV_EGR_CC4G(x) TIM1_EGR_CC4G(x) + +#define TIM_ADV_EGR_CC3G_SHIFT TIM1_EGR_CC3G_SHIFT +#define TIM_ADV_EGR_CC3G_MASK TIM1_EGR_CC3G_MASK +#define TIM_ADV_EGR_CC3G(x) TIM1_EGR_CC3G(x) + +#define TIM_ADV_EGR_CC2G_SHIFT TIM1_EGR_CC2G_SHIFT +#define TIM_ADV_EGR_CC2G_MASK TIM1_EGR_CC2G_MASK +#define TIM_ADV_EGR_CC2G(x) TIM1_EGR_CC2G(x) + +#define TIM_ADV_EGR_CC1G_SHIFT TIM1_EGR_CC1G_SHIFT +#define TIM_ADV_EGR_CC1G_MASK TIM1_EGR_CC1G_MASK +#define TIM_ADV_EGR_CC1G(x) TIM1_EGR_CC1G(x) + +#define TIM_ADV_EGR_UG_SHIFT TIM1_EGR_UG_SHIFT +#define TIM_ADV_EGR_UG_MASK TIM1_EGR_UG_MASK +#define TIM_ADV_EGR_UG(x) TIM1_EGR_UG(x) + +/*! + * @brief TIM_ADV_CCMR1 Register Bit Definition + */ + +#define TIM_ADV_CCMR1_OC2CE_SHIFT TIM1_CCMR1_OC2CE_SHIFT +#define TIM_ADV_CCMR1_OC2CE_MASK TIM1_CCMR1_OC2CE_MASK +#define TIM_ADV_CCMR1_OC2CE(x) TIM1_CCMR1_OC2CE(x) + +#define TIM_ADV_CCMR1_OC2M_SHIFT TIM1_CCMR1_OC2M_SHIFT +#define TIM_ADV_CCMR1_OC2M_MASK TIM1_CCMR1_OC2M_MASK +#define TIM_ADV_CCMR1_OC2M(x) TIM1_CCMR1_OC2M(x) + +#define TIM_ADV_CCMR1_OC2PE_SHIFT TIM1_CCMR1_OC2PE_SHIFT +#define TIM_ADV_CCMR1_OC2PE_MASK TIM1_CCMR1_OC2PE_MASK +#define TIM_ADV_CCMR1_OC2PE(x) TIM1_CCMR1_OC2PE(x) + +#define TIM_ADV_CCMR1_OC2FE_SHIFT TIM1_CCMR1_OC2FE_SHIFT +#define TIM_ADV_CCMR1_OC2FE_MASK TIM1_CCMR1_OC2FE_MASK +#define TIM_ADV_CCMR1_OC2FE(x) TIM1_CCMR1_OC2FE(x) + +#define TIM_ADV_CCMR1_CC2S_SHIFT TIM1_CCMR1_CC2S_SHIFT +#define TIM_ADV_CCMR1_CC2S_MASK TIM1_CCMR1_CC2S_MASK +#define TIM_ADV_CCMR1_CC2S(x) TIM1_CCMR1_CC2S(x) + +#define TIM_ADV_CCMR1_OC1CE_SHIFT TIM1_CCMR1_OC1CE_SHIFT +#define TIM_ADV_CCMR1_OC1CE_MASK TIM1_CCMR1_OC1CE_MASK +#define TIM_ADV_CCMR1_OC1CE(x) TIM1_CCMR1_OC1CE(x) + +#define TIM_ADV_CCMR1_OC1M_SHIFT TIM1_CCMR1_OC1M_SHIFT +#define TIM_ADV_CCMR1_OC1M_MASK TIM1_CCMR1_OC1M_MASK +#define TIM_ADV_CCMR1_OC1M(x) TIM1_CCMR1_OC1M(x) + +#define TIM_ADV_CCMR1_OC1PE_SHIFT TIM1_CCMR1_OC1PE_SHIFT +#define TIM_ADV_CCMR1_OC1PE_MASK TIM1_CCMR1_OC1PE_MASK +#define TIM_ADV_CCMR1_OC1PE(x) TIM1_CCMR1_OC1PE(x) + +#define TIM_ADV_CCMR1_OC1FE_SHIFT TIM1_CCMR1_OC1FE_SHIFT +#define TIM_ADV_CCMR1_OC1FE_MASK TIM1_CCMR1_OC1FE_MASK +#define TIM_ADV_CCMR1_OC1FE(x) TIM1_CCMR1_OC1FE(x) + +#define TIM_ADV_CCMR1_CC1S_SHIFT TIM1_CCMR1_CC1S_SHIFT +#define TIM_ADV_CCMR1_CC1S_MASK TIM1_CCMR1_CC1S_MASK +#define TIM_ADV_CCMR1_CC1S(x) TIM1_CCMR1_CC1S(x) + +/*! + * @brief TIM_ADV_CCMR1 Register Bit Definition + */ + +#define TIM_ADV_CCMR1_IC2F_SHIFT TIM1_CCMR1_IC2F_SHIFT +#define TIM_ADV_CCMR1_IC2F_MASK TIM1_CCMR1_IC2F_MASK +#define TIM_ADV_CCMR1_IC2F(x) TIM1_CCMR1_IC2F(x) + +#define TIM_ADV_CCMR1_IC2PSC_SHIFT TIM1_CCMR1_IC2PSC_SHIFT +#define TIM_ADV_CCMR1_IC2PSC_MASK TIM1_CCMR1_IC2PSC_MASK +#define TIM_ADV_CCMR1_IC2PSC(x) TIM1_CCMR1_IC2PSC(x) + +#define TIM_ADV_CCMR1_CC2S_SHIFT TIM1_CCMR1_CC2S_SHIFT +#define TIM_ADV_CCMR1_CC2S_MASK TIM1_CCMR1_CC2S_MASK +#define TIM_ADV_CCMR1_CC2S(x) TIM1_CCMR1_CC2S(x) + +#define TIM_ADV_CCMR1_IC1F_SHIFT TIM1_CCMR1_IC1F_SHIFT +#define TIM_ADV_CCMR1_IC1F_MASK TIM1_CCMR1_IC1F_MASK +#define TIM_ADV_CCMR1_IC1F(x) TIM1_CCMR1_IC1F(x) + +#define TIM_ADV_CCMR1_IC1PSC_SHIFT TIM1_CCMR1_IC1PSC_SHIFT +#define TIM_ADV_CCMR1_IC1PSC_MASK TIM1_CCMR1_IC1PSC_MASK +#define TIM_ADV_CCMR1_IC1PSC(x) TIM1_CCMR1_IC1PSC(x) + +#define TIM_ADV_CCMR1_CC1S_SHIFT TIM1_CCMR1_CC1S_SHIFT +#define TIM_ADV_CCMR1_CC1S_MASK TIM1_CCMR1_CC1S_MASK +#define TIM_ADV_CCMR1_CC1S(x) TIM1_CCMR1_CC1S(x) + +/*! + * @brief TIM_ADV_CCMR2 Register Bit Definition + */ + +#define TIM_ADV_CCMR2_OC4CE_SHIFT TIM1_CCMR2_OC4CE_SHIFT +#define TIM_ADV_CCMR2_OC4CE_MASK TIM1_CCMR2_OC4CE_MASK +#define TIM_ADV_CCMR2_OC4CE(x) TIM1_CCMR2_OC4CE(x) + +#define TIM_ADV_CCMR2_OC4M_SHIFT TIM1_CCMR2_OC4M_SHIFT +#define TIM_ADV_CCMR2_OC4M_MASK TIM1_CCMR2_OC4M_MASK +#define TIM_ADV_CCMR2_OC4M(x) TIM1_CCMR2_OC4M(x) + +#define TIM_ADV_CCMR2_OC4PE_SHIFT TIM1_CCMR2_OC4PE_SHIFT +#define TIM_ADV_CCMR2_OC4PE_MASK TIM1_CCMR2_OC4PE_MASK +#define TIM_ADV_CCMR2_OC4PE(x) TIM1_CCMR2_OC4PE(x) + +#define TIM_ADV_CCMR2_OC4FE_SHIFT TIM1_CCMR2_OC4FE_SHIFT +#define TIM_ADV_CCMR2_OC4FE_MASK TIM1_CCMR2_OC4FE_MASK +#define TIM_ADV_CCMR2_OC4FE(x) TIM1_CCMR2_OC4FE(x) + +#define TIM_ADV_CCMR2_CC4S_SHIFT TIM1_CCMR2_CC4S_SHIFT +#define TIM_ADV_CCMR2_CC4S_MASK TIM1_CCMR2_CC4S_MASK +#define TIM_ADV_CCMR2_CC4S(x) TIM1_CCMR2_CC4S(x) + +#define TIM_ADV_CCMR2_OC3CE_SHIFT TIM1_CCMR2_OC3CE_SHIFT +#define TIM_ADV_CCMR2_OC3CE_MASK TIM1_CCMR2_OC3CE_MASK +#define TIM_ADV_CCMR2_OC3CE(x) TIM1_CCMR2_OC3CE(x) + +#define TIM_ADV_CCMR2_OC3M_SHIFT TIM1_CCMR2_OC3M_SHIFT +#define TIM_ADV_CCMR2_OC3M_MASK TIM1_CCMR2_OC3M_MASK +#define TIM_ADV_CCMR2_OC3M(x) TIM1_CCMR2_OC3M(x) + +#define TIM_ADV_CCMR2_OC3PE_SHIFT TIM1_CCMR2_OC3PE_SHIFT +#define TIM_ADV_CCMR2_OC3PE_MASK TIM1_CCMR2_OC3PE_MASK +#define TIM_ADV_CCMR2_OC3PE(x) TIM1_CCMR2_OC3PE(x) + +#define TIM_ADV_CCMR2_OC3FE_SHIFT TIM1_CCMR2_OC3FE_SHIFT +#define TIM_ADV_CCMR2_OC3FE_MASK TIM1_CCMR2_OC3FE_MASK +#define TIM_ADV_CCMR2_OC3FE(x) TIM1_CCMR2_OC3FE(x) + +#define TIM_ADV_CCMR2_CC3S_SHIFT TIM1_CCMR2_CC3S_SHIFT +#define TIM_ADV_CCMR2_CC3S_MASK TIM1_CCMR2_CC3S_MASK +#define TIM_ADV_CCMR2_CC3S(x) TIM1_CCMR2_CC3S(x) + +/*! + * @brief TIM_ADV_CCMR2 Register Bit Definition + */ + +#define TIM_ADV_CCMR2_IC4F_SHIFT TIM1_CCMR2_IC4F_SHIFT +#define TIM_ADV_CCMR2_IC4F_MASK TIM1_CCMR2_IC4F_MASK +#define TIM_ADV_CCMR2_IC4F(x) TIM1_CCMR2_IC4F(x) + +#define TIM_ADV_CCMR2_IC4PSC_SHIFT TIM1_CCMR2_IC4PSC_SHIFT +#define TIM_ADV_CCMR2_IC4PSC_MASK TIM1_CCMR2_IC4PSC_MASK +#define TIM_ADV_CCMR2_IC4PSC(x) TIM1_CCMR2_IC4PSC(x) + +#define TIM_ADV_CCMR2_CC4S_SHIFT TIM1_CCMR2_CC4S_SHIFT +#define TIM_ADV_CCMR2_CC4S_MASK TIM1_CCMR2_CC4S_MASK +#define TIM_ADV_CCMR2_CC4S(x) TIM1_CCMR2_CC4S(x) + +#define TIM_ADV_CCMR2_IC3F_SHIFT TIM1_CCMR2_IC3F_SHIFT +#define TIM_ADV_CCMR2_IC3F_MASK TIM1_CCMR2_IC3F_MASK +#define TIM_ADV_CCMR2_IC3F(x) TIM1_CCMR2_IC3F(x) + +#define TIM_ADV_CCMR2_IC3PSC_SHIFT TIM1_CCMR2_IC3PSC_SHIFT +#define TIM_ADV_CCMR2_IC3PSC_MASK TIM1_CCMR2_IC3PSC_MASK +#define TIM_ADV_CCMR2_IC3PSC(x) TIM1_CCMR2_IC3PSC(x) + +#define TIM_ADV_CCMR2_CC3S_SHIFT TIM1_CCMR2_CC3S_SHIFT +#define TIM_ADV_CCMR2_CC3S_MASK TIM1_CCMR2_CC3S_MASK +#define TIM_ADV_CCMR2_CC3S(x) TIM1_CCMR2_CC3S(x) + +/*! + * @brief TIM_ADV_CCER Register Bit Definition + */ + +#define TIM_ADV_CCER_CC4NP_SHIFT TIM1_CCER_CC4NP_SHIFT +#define TIM_ADV_CCER_CC4NP_MASK TIM1_CCER_CC4NP_MASK +#define TIM_ADV_CCER_CC4NP(x) TIM1_CCER_CC4NP(x) + +#define TIM_ADV_CCER_CC4P_SHIFT TIM1_CCER_CC4P_SHIFT +#define TIM_ADV_CCER_CC4P_MASK TIM1_CCER_CC4P_MASK +#define TIM_ADV_CCER_CC4P(x) TIM1_CCER_CC4P(x) + +#define TIM_ADV_CCER_CC4E_SHIFT TIM1_CCER_CC4E_SHIFT +#define TIM_ADV_CCER_CC4E_MASK TIM1_CCER_CC4E_MASK +#define TIM_ADV_CCER_CC4E(x) TIM1_CCER_CC4E(x) + +#define TIM_ADV_CCER_CC3NP_SHIFT TIM1_CCER_CC3NP_SHIFT +#define TIM_ADV_CCER_CC3NP_MASK TIM1_CCER_CC3NP_MASK +#define TIM_ADV_CCER_CC3NP(x) TIM1_CCER_CC3NP(x) + +#define TIM_ADV_CCER_CC3NE_SHIFT TIM1_CCER_CC3NE_SHIFT +#define TIM_ADV_CCER_CC3NE_MASK TIM1_CCER_CC3NE_MASK +#define TIM_ADV_CCER_CC3NE(x) TIM1_CCER_CC3NE(x) + +#define TIM_ADV_CCER_CC3P_SHIFT TIM1_CCER_CC3P_SHIFT +#define TIM_ADV_CCER_CC3P_MASK TIM1_CCER_CC3P_MASK +#define TIM_ADV_CCER_CC3P(x) TIM1_CCER_CC3P(x) + +#define TIM_ADV_CCER_CC3E_SHIFT TIM1_CCER_CC3E_SHIFT +#define TIM_ADV_CCER_CC3E_MASK TIM1_CCER_CC3E_MASK +#define TIM_ADV_CCER_CC3E(x) TIM1_CCER_CC3E(x) + +#define TIM_ADV_CCER_CC2NP_SHIFT TIM1_CCER_CC2NP_SHIFT +#define TIM_ADV_CCER_CC2NP_MASK TIM1_CCER_CC2NP_MASK +#define TIM_ADV_CCER_CC2NP(x) TIM1_CCER_CC2NP(x) + +#define TIM_ADV_CCER_CC2NE_SHIFT TIM1_CCER_CC2NE_SHIFT +#define TIM_ADV_CCER_CC2NE_MASK TIM1_CCER_CC2NE_MASK +#define TIM_ADV_CCER_CC2NE(x) TIM1_CCER_CC2NE(x) + +#define TIM_ADV_CCER_CC2P_SHIFT TIM1_CCER_CC2P_SHIFT +#define TIM_ADV_CCER_CC2P_MASK TIM1_CCER_CC2P_MASK +#define TIM_ADV_CCER_CC2P(x) TIM1_CCER_CC2P(x) + +#define TIM_ADV_CCER_CC2E_SHIFT TIM1_CCER_CC2E_SHIFT +#define TIM_ADV_CCER_CC2E_MASK TIM1_CCER_CC2E_MASK +#define TIM_ADV_CCER_CC2E(x) TIM1_CCER_CC2E(x) + +#define TIM_ADV_CCER_CC1NP_SHIFT TIM1_CCER_CC1NP_SHIFT +#define TIM_ADV_CCER_CC1NP_MASK TIM1_CCER_CC1NP_MASK +#define TIM_ADV_CCER_CC1NP(x) TIM1_CCER_CC1NP(x) + +#define TIM_ADV_CCER_CC1NE_SHIFT TIM1_CCER_CC1NE_SHIFT +#define TIM_ADV_CCER_CC1NE_MASK TIM1_CCER_CC1NE_MASK +#define TIM_ADV_CCER_CC1NE(x) TIM1_CCER_CC1NE(x) + +#define TIM_ADV_CCER_CC1P_SHIFT TIM1_CCER_CC1P_SHIFT +#define TIM_ADV_CCER_CC1P_MASK TIM1_CCER_CC1P_MASK +#define TIM_ADV_CCER_CC1P(x) TIM1_CCER_CC1P(x) + +#define TIM_ADV_CCER_CC1E_SHIFT TIM1_CCER_CC1E_SHIFT +#define TIM_ADV_CCER_CC1E_MASK TIM1_CCER_CC1E_MASK +#define TIM_ADV_CCER_CC1E(x) TIM1_CCER_CC1E(x) + +/*! + * @brief TIM_ADV_CNT Register Bit Definition + */ + +#define TIM_ADV_CNT_CNT_SHIFT TIM1_CNT_CNT_SHIFT +#define TIM_ADV_CNT_CNT_MASK TIM1_CNT_CNT_MASK +#define TIM_ADV_CNT_CNT(x) TIM1_CNT_CNT(x) + +/*! + * @brief TIM_ADV_PSC Register Bit Definition + */ + +#define TIM_ADV_PSC_PSC_SHIFT TIM1_PSC_PSC_SHIFT +#define TIM_ADV_PSC_PSC_MASK TIM1_PSC_PSC_MASK +#define TIM_ADV_PSC_PSC(x) TIM1_PSC_PSC(x) + +/*! + * @brief TIM_ADV_ARR Register Bit Definition + */ + +#define TIM_ADV_ARR_ARR_SHIFT TIM1_ARR_ARR_SHIFT +#define TIM_ADV_ARR_ARR_MASK TIM1_ARR_ARR_MASK +#define TIM_ADV_ARR_ARR(x) TIM1_ARR_ARR(x) + +/*! + * @brief TIM_ADV_RCR Register Bit Definition + */ + +#define TIM_ADV_RCR_REPCNT_SHIFT TIM1_RCR_REPCNT_SHIFT +#define TIM_ADV_RCR_REPCNT_MASK TIM1_RCR_REPCNT_MASK +#define TIM_ADV_RCR_REPCNT(x) TIM1_RCR_REPCNT(x) + +#define TIM_ADV_RCR_REP_SHIFT TIM1_RCR_REP_SHIFT +#define TIM_ADV_RCR_REP_MASK TIM1_RCR_REP_MASK +#define TIM_ADV_RCR_REP(x) TIM1_RCR_REP(x) + +/*! + * @brief TIM_ADV_CCR1 Register Bit Definition + */ + +#define TIM_ADV_CCR1_CCR1_SHIFT TIM1_CCR1_CCR1_SHIFT +#define TIM_ADV_CCR1_CCR1_MASK TIM1_CCR1_CCR1_MASK +#define TIM_ADV_CCR1_CCR1(x) TIM1_CCR1_CCR1(x) + +/*! + * @brief TIM_ADV_CCR2 Register Bit Definition + */ + +#define TIM_ADV_CCR2_CCR2_SHIFT TIM1_CCR2_CCR2_SHIFT +#define TIM_ADV_CCR2_CCR2_MASK TIM1_CCR2_CCR2_MASK +#define TIM_ADV_CCR2_CCR2(x) TIM1_CCR2_CCR2(x) + +/*! + * @brief TIM_ADV_CCR3 Register Bit Definition + */ + +#define TIM_ADV_CCR3_CCR3_SHIFT TIM1_CCR3_CCR3_SHIFT +#define TIM_ADV_CCR3_CCR3_MASK TIM1_CCR3_CCR3_MASK +#define TIM_ADV_CCR3_CCR3(x) TIM1_CCR3_CCR3(x) + +/*! + * @brief TIM_ADV_CCR4 Register Bit Definition + */ + +#define TIM_ADV_CCR4_CCR4_SHIFT TIM1_CCR4_CCR4_SHIFT +#define TIM_ADV_CCR4_CCR4_MASK TIM1_CCR4_CCR4_MASK +#define TIM_ADV_CCR4_CCR4(x) TIM1_CCR4_CCR4(x) + +/*! + * @brief TIM_ADV_BDTR Register Bit Definition + */ + +#define TIM_ADV_BDTR_DOE_SHIFT TIM1_BDTR_DOE_SHIFT +#define TIM_ADV_BDTR_DOE_MASK TIM1_BDTR_DOE_MASK +#define TIM_ADV_BDTR_DOE(x) TIM1_BDTR_DOE(x) + +#define TIM_ADV_BDTR_MOE_SHIFT TIM1_BDTR_MOE_SHIFT +#define TIM_ADV_BDTR_MOE_MASK TIM1_BDTR_MOE_MASK +#define TIM_ADV_BDTR_MOE(x) TIM1_BDTR_MOE(x) + +#define TIM_ADV_BDTR_AOE_SHIFT TIM1_BDTR_AOE_SHIFT +#define TIM_ADV_BDTR_AOE_MASK TIM1_BDTR_AOE_MASK +#define TIM_ADV_BDTR_AOE(x) TIM1_BDTR_AOE(x) + +#define TIM_ADV_BDTR_BKP_SHIFT TIM1_BDTR_BKP_SHIFT +#define TIM_ADV_BDTR_BKP_MASK TIM1_BDTR_BKP_MASK +#define TIM_ADV_BDTR_BKP(x) TIM1_BDTR_BKP(x) + +#define TIM_ADV_BDTR_BKE_SHIFT TIM1_BDTR_BKE_SHIFT +#define TIM_ADV_BDTR_BKE_MASK TIM1_BDTR_BKE_MASK +#define TIM_ADV_BDTR_BKE(x) TIM1_BDTR_BKE(x) + +#define TIM_ADV_BDTR_OSSR_SHIFT TIM1_BDTR_OSSR_SHIFT +#define TIM_ADV_BDTR_OSSR_MASK TIM1_BDTR_OSSR_MASK +#define TIM_ADV_BDTR_OSSR(x) TIM1_BDTR_OSSR(x) + +#define TIM_ADV_BDTR_OSSI_SHIFT TIM1_BDTR_OSSI_SHIFT +#define TIM_ADV_BDTR_OSSI_MASK TIM1_BDTR_OSSI_MASK +#define TIM_ADV_BDTR_OSSI(x) TIM1_BDTR_OSSI(x) + +#define TIM_ADV_BDTR_LOCK_SHIFT TIM1_BDTR_LOCK_SHIFT +#define TIM_ADV_BDTR_LOCK_MASK TIM1_BDTR_LOCK_MASK +#define TIM_ADV_BDTR_LOCK(x) TIM1_BDTR_LOCK(x) + +#define TIM_ADV_BDTR_DTG_SHIFT TIM1_BDTR_DTG_SHIFT +#define TIM_ADV_BDTR_DTG_MASK TIM1_BDTR_DTG_MASK +#define TIM_ADV_BDTR_DTG(x) TIM1_BDTR_DTG(x) + +/*! + * @brief TIM_ADV_DCR Register Bit Definition + */ + +#define TIM_ADV_DCR_DBL_SHIFT TIM1_DCR_DBL_SHIFT +#define TIM_ADV_DCR_DBL_MASK TIM1_DCR_DBL_MASK +#define TIM_ADV_DCR_DBL(x) TIM1_DCR_DBL(x) + +#define TIM_ADV_DCR_DBA_SHIFT TIM1_DCR_DBA_SHIFT +#define TIM_ADV_DCR_DBA_MASK TIM1_DCR_DBA_MASK +#define TIM_ADV_DCR_DBA(x) TIM1_DCR_DBA(x) + +/*! + * @brief TIM_ADV_DMAR Register Bit Definition + */ + +#define TIM_ADV_DMAR_DMAB_SHIFT TIM1_DMAR_DMAB_SHIFT +#define TIM_ADV_DMAR_DMAB_MASK TIM1_DMAR_DMAB_MASK +#define TIM_ADV_DMAR_DMAB(x) TIM1_DMAR_DMAB(x) + +/*! + * @brief TIM_ADV_CCMR3 Register Bit Definition + */ + +#define TIM_ADV_CCMR3_OC5M_SHIFT TIM1_CCMR3_OC5M_SHIFT +#define TIM_ADV_CCMR3_OC5M_MASK TIM1_CCMR3_OC5M_MASK +#define TIM_ADV_CCMR3_OC5M(x) TIM1_CCMR3_OC5M(x) + +#define TIM_ADV_CCMR3_OC5PE_SHIFT TIM1_CCMR3_OC5PE_SHIFT +#define TIM_ADV_CCMR3_OC5PE_MASK TIM1_CCMR3_OC5PE_MASK +#define TIM_ADV_CCMR3_OC5PE(x) TIM1_CCMR3_OC5PE(x) + +#define TIM_ADV_CCMR3_OC5FE_SHIFT TIM1_CCMR3_OC5FE_SHIFT +#define TIM_ADV_CCMR3_OC5FE_MASK TIM1_CCMR3_OC5FE_MASK +#define TIM_ADV_CCMR3_OC5FE(x) TIM1_CCMR3_OC5FE(x) + +/*! + * @brief TIM_ADV_CCR5 Register Bit Definition + */ + +#define TIM_ADV_CCR5_CCR5_SHIFT TIM1_CCR5_CCR5_SHIFT +#define TIM_ADV_CCR5_CCR5_MASK TIM1_CCR5_CCR5_MASK +#define TIM_ADV_CCR5_CCR5(x) TIM1_CCR5_CCR5(x) + +/*! + * @brief TIM_ADV_PDER Register Bit Definition + */ + +#define TIM_ADV_PDER_CCR5SHIFTEN_SHIFT TIM1_PDER_CCR5SHIFTEN_SHIFT +#define TIM_ADV_PDER_CCR5SHIFTEN_MASK TIM1_PDER_CCR5SHIFTEN_MASK +#define TIM_ADV_PDER_CCR5SHIFTEN(x) TIM1_PDER_CCR5SHIFTEN(x) + +#define TIM_ADV_PDER_CCR4SHIFTEN_SHIFT TIM1_PDER_CCR4SHIFTEN_SHIFT +#define TIM_ADV_PDER_CCR4SHIFTEN_MASK TIM1_PDER_CCR4SHIFTEN_MASK +#define TIM_ADV_PDER_CCR4SHIFTEN(x) TIM1_PDER_CCR4SHIFTEN(x) + +#define TIM_ADV_PDER_CCR3SHIFTEN_SHIFT TIM1_PDER_CCR3SHIFTEN_SHIFT +#define TIM_ADV_PDER_CCR3SHIFTEN_MASK TIM1_PDER_CCR3SHIFTEN_MASK +#define TIM_ADV_PDER_CCR3SHIFTEN(x) TIM1_PDER_CCR3SHIFTEN(x) + +#define TIM_ADV_PDER_CCR2SHIFTEN_SHIFT TIM1_PDER_CCR2SHIFTEN_SHIFT +#define TIM_ADV_PDER_CCR2SHIFTEN_MASK TIM1_PDER_CCR2SHIFTEN_MASK +#define TIM_ADV_PDER_CCR2SHIFTEN(x) TIM1_PDER_CCR2SHIFTEN(x) + +#define TIM_ADV_PDER_CCR1SHIFTEN_SHIFT TIM1_PDER_CCR1SHIFTEN_SHIFT +#define TIM_ADV_PDER_CCR1SHIFTEN_MASK TIM1_PDER_CCR1SHIFTEN_MASK +#define TIM_ADV_PDER_CCR1SHIFTEN(x) TIM1_PDER_CCR1SHIFTEN(x) + +#define TIM_ADV_PDER_CCDREPE_SHIFT TIM1_PDER_CCDREPE_SHIFT +#define TIM_ADV_PDER_CCDREPE_MASK TIM1_PDER_CCDREPE_MASK +#define TIM_ADV_PDER_CCDREPE(x) TIM1_PDER_CCDREPE(x) + +/*! + * @brief TIM_ADV_CCRFALL Register Bit Definition + */ + +#define TIM_ADV_CCRFALL_CCRXFALL_SHIFT TIM1_CCRFALL_CCRXFALL_SHIFT +#define TIM_ADV_CCRFALL_CCRXFALL_MASK TIM1_CCRFALL_CCRXFALL_MASK +#define TIM_ADV_CCRFALL_CCRXFALL(x) TIM1_CCRFALL_CCRXFALL(x) + +/*! + * @} + */ /* end of group TIM_ADV_Register_Masks */ + +/******************************************************************************* + * TIM_16B Type + ******************************************************************************/ + +/*! + * @addtogroup TIM_16B_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM_16B_CR1 Register Bit Definition + */ + +#define TIM_16B_CR1_CKD_SHIFT TIM3_CR1_CKD_SHIFT +#define TIM_16B_CR1_CKD_MASK TIM3_CR1_CKD_MASK +#define TIM_16B_CR1_CKD(x) TIM3_CR1_CKD(x) + +#define TIM_16B_CR1_APRE_SHIFT TIM3_CR1_APRE_SHIFT +#define TIM_16B_CR1_APRE_MASK TIM3_CR1_APRE_MASK +#define TIM_16B_CR1_APRE(x) TIM3_CR1_APRE(x) + +#define TIM_16B_CR1_CMS_SHIFT TIM3_CR1_CMS_SHIFT +#define TIM_16B_CR1_CMS_MASK TIM3_CR1_CMS_MASK +#define TIM_16B_CR1_CMS(x) TIM3_CR1_CMS(x) + +#define TIM_16B_CR1_DIR_SHIFT TIM3_CR1_DIR_SHIFT +#define TIM_16B_CR1_DIR_MASK TIM3_CR1_DIR_MASK +#define TIM_16B_CR1_DIR(x) TIM3_CR1_DIR(x) + +#define TIM_16B_CR1_OPM_SHIFT TIM3_CR1_OPM_SHIFT +#define TIM_16B_CR1_OPM_MASK TIM3_CR1_OPM_MASK +#define TIM_16B_CR1_OPM(x) TIM3_CR1_OPM(x) + +#define TIM_16B_CR1_URS_SHIFT TIM3_CR1_URS_SHIFT +#define TIM_16B_CR1_URS_MASK TIM3_CR1_URS_MASK +#define TIM_16B_CR1_URS(x) TIM3_CR1_URS(x) + +#define TIM_16B_CR1_UDIS_SHIFT TIM3_CR1_UDIS_SHIFT +#define TIM_16B_CR1_UDIS_MASK TIM3_CR1_UDIS_MASK +#define TIM_16B_CR1_UDIS(x) TIM3_CR1_UDIS(x) + +#define TIM_16B_CR1_CEN_SHIFT TIM3_CR1_CEN_SHIFT +#define TIM_16B_CR1_CEN_MASK TIM3_CR1_CEN_MASK +#define TIM_16B_CR1_CEN(x) TIM3_CR1_CEN(x) + +/*! + * @brief TIM_16B_CR2 Register Bit Definition + */ + +#define TIM_16B_CR2_TI1S_SHIFT TIM3_CR2_TI1S_SHIFT +#define TIM_16B_CR2_TI1S_MASK TIM3_CR2_TI1S_MASK +#define TIM_16B_CR2_TI1S(x) TIM3_CR2_TI1S(x) + +#define TIM_16B_CR2_MMS_SHIFT TIM3_CR2_MMS_SHIFT +#define TIM_16B_CR2_MMS_MASK TIM3_CR2_MMS_MASK +#define TIM_16B_CR2_MMS(x) TIM3_CR2_MMS(x) + +#define TIM_16B_CR2_CCDS_SHIFT TIM3_CR2_CCDS_SHIFT +#define TIM_16B_CR2_CCDS_MASK TIM3_CR2_CCDS_MASK +#define TIM_16B_CR2_CCDS(x) TIM3_CR2_CCDS(x) + +/*! + * @brief TIM_16B_SMCR Register Bit Definition + */ + +#define TIM_16B_SMCR_ETP_SHIFT TIM3_SMCR_ETP_SHIFT +#define TIM_16B_SMCR_ETP_MASK TIM3_SMCR_ETP_MASK +#define TIM_16B_SMCR_ETP(x) TIM3_SMCR_ETP(x) + +#define TIM_16B_SMCR_ECE_SHIFT TIM3_SMCR_ECE_SHIFT +#define TIM_16B_SMCR_ECE_MASK TIM3_SMCR_ECE_MASK +#define TIM_16B_SMCR_ECE(x) TIM3_SMCR_ECE(x) + +#define TIM_16B_SMCR_ETPS_SHIFT TIM3_SMCR_ETPS_SHIFT +#define TIM_16B_SMCR_ETPS_MASK TIM3_SMCR_ETPS_MASK +#define TIM_16B_SMCR_ETPS(x) TIM3_SMCR_ETPS(x) + +#define TIM_16B_SMCR_ETF_SHIFT TIM3_SMCR_ETF_SHIFT +#define TIM_16B_SMCR_ETF_MASK TIM3_SMCR_ETF_MASK +#define TIM_16B_SMCR_ETF(x) TIM3_SMCR_ETF(x) + +#define TIM_16B_SMCR_MSM_SHIFT TIM3_SMCR_MSM_SHIFT +#define TIM_16B_SMCR_MSM_MASK TIM3_SMCR_MSM_MASK +#define TIM_16B_SMCR_MSM(x) TIM3_SMCR_MSM(x) + +#define TIM_16B_SMCR_TS_SHIFT TIM3_SMCR_TS_SHIFT +#define TIM_16B_SMCR_TS_MASK TIM3_SMCR_TS_MASK +#define TIM_16B_SMCR_TS(x) TIM3_SMCR_TS(x) + +#define TIM_16B_SMCR_OCCS_SHIFT TIM3_SMCR_OCCS_SHIFT +#define TIM_16B_SMCR_OCCS_MASK TIM3_SMCR_OCCS_MASK +#define TIM_16B_SMCR_OCCS(x) TIM3_SMCR_OCCS(x) + +#define TIM_16B_SMCR_SMS_SHIFT TIM3_SMCR_SMS_SHIFT +#define TIM_16B_SMCR_SMS_MASK TIM3_SMCR_SMS_MASK +#define TIM_16B_SMCR_SMS(x) TIM3_SMCR_SMS(x) + +/*! + * @brief TIM_16B_DIER Register Bit Definition + */ + +#define TIM_16B_DIER_TDE_SHIFT TIM3_DIER_TDE_SHIFT +#define TIM_16B_DIER_TDE_MASK TIM3_DIER_TDE_MASK +#define TIM_16B_DIER_TDE(x) TIM3_DIER_TDE(x) + +#define TIM_16B_DIER_CC4DE_SHIFT TIM3_DIER_CC4DE_SHIFT +#define TIM_16B_DIER_CC4DE_MASK TIM3_DIER_CC4DE_MASK +#define TIM_16B_DIER_CC4DE(x) TIM3_DIER_CC4DE(x) + +#define TIM_16B_DIER_CC3DE_SHIFT TIM3_DIER_CC3DE_SHIFT +#define TIM_16B_DIER_CC3DE_MASK TIM3_DIER_CC3DE_MASK +#define TIM_16B_DIER_CC3DE(x) TIM3_DIER_CC3DE(x) + +#define TIM_16B_DIER_CC2DE_SHIFT TIM3_DIER_CC2DE_SHIFT +#define TIM_16B_DIER_CC2DE_MASK TIM3_DIER_CC2DE_MASK +#define TIM_16B_DIER_CC2DE(x) TIM3_DIER_CC2DE(x) + +#define TIM_16B_DIER_CC1DE_SHIFT TIM3_DIER_CC1DE_SHIFT +#define TIM_16B_DIER_CC1DE_MASK TIM3_DIER_CC1DE_MASK +#define TIM_16B_DIER_CC1DE(x) TIM3_DIER_CC1DE(x) + +#define TIM_16B_DIER_UDE_SHIFT TIM3_DIER_UDE_SHIFT +#define TIM_16B_DIER_UDE_MASK TIM3_DIER_UDE_MASK +#define TIM_16B_DIER_UDE(x) TIM3_DIER_UDE(x) + +#define TIM_16B_DIER_TIE_SHIFT TIM3_DIER_TIE_SHIFT +#define TIM_16B_DIER_TIE_MASK TIM3_DIER_TIE_MASK +#define TIM_16B_DIER_TIE(x) TIM3_DIER_TIE(x) + +#define TIM_16B_DIER_CC4IE_SHIFT TIM3_DIER_CC4IE_SHIFT +#define TIM_16B_DIER_CC4IE_MASK TIM3_DIER_CC4IE_MASK +#define TIM_16B_DIER_CC4IE(x) TIM3_DIER_CC4IE(x) + +#define TIM_16B_DIER_CC3IE_SHIFT TIM3_DIER_CC3IE_SHIFT +#define TIM_16B_DIER_CC3IE_MASK TIM3_DIER_CC3IE_MASK +#define TIM_16B_DIER_CC3IE(x) TIM3_DIER_CC3IE(x) + +#define TIM_16B_DIER_CC2IE_SHIFT TIM3_DIER_CC2IE_SHIFT +#define TIM_16B_DIER_CC2IE_MASK TIM3_DIER_CC2IE_MASK +#define TIM_16B_DIER_CC2IE(x) TIM3_DIER_CC2IE(x) + +#define TIM_16B_DIER_CC1IE_SHIFT TIM3_DIER_CC1IE_SHIFT +#define TIM_16B_DIER_CC1IE_MASK TIM3_DIER_CC1IE_MASK +#define TIM_16B_DIER_CC1IE(x) TIM3_DIER_CC1IE(x) + +#define TIM_16B_DIER_UIE_SHIFT TIM3_DIER_UIE_SHIFT +#define TIM_16B_DIER_UIE_MASK TIM3_DIER_UIE_MASK +#define TIM_16B_DIER_UIE(x) TIM3_DIER_UIE(x) + +/*! + * @brief TIM_16B_SR Register Bit Definition + */ + +#define TIM_16B_SR_CC4OF_SHIFT TIM3_SR_CC4OF_SHIFT +#define TIM_16B_SR_CC4OF_MASK TIM3_SR_CC4OF_MASK +#define TIM_16B_SR_CC4OF(x) TIM3_SR_CC4OF(x) + +#define TIM_16B_SR_CC3OF_SHIFT TIM3_SR_CC3OF_SHIFT +#define TIM_16B_SR_CC3OF_MASK TIM3_SR_CC3OF_MASK +#define TIM_16B_SR_CC3OF(x) TIM3_SR_CC3OF(x) + +#define TIM_16B_SR_CC2OF_SHIFT TIM3_SR_CC2OF_SHIFT +#define TIM_16B_SR_CC2OF_MASK TIM3_SR_CC2OF_MASK +#define TIM_16B_SR_CC2OF(x) TIM3_SR_CC2OF(x) + +#define TIM_16B_SR_CC1OF_SHIFT TIM3_SR_CC1OF_SHIFT +#define TIM_16B_SR_CC1OF_MASK TIM3_SR_CC1OF_MASK +#define TIM_16B_SR_CC1OF(x) TIM3_SR_CC1OF(x) + +#define TIM_16B_SR_TIF_SHIFT TIM3_SR_TIF_SHIFT +#define TIM_16B_SR_TIF_MASK TIM3_SR_TIF_MASK +#define TIM_16B_SR_TIF(x) TIM3_SR_TIF(x) + +#define TIM_16B_SR_CC4IF_SHIFT TIM3_SR_CC4IF_SHIFT +#define TIM_16B_SR_CC4IF_MASK TIM3_SR_CC4IF_MASK +#define TIM_16B_SR_CC4IF(x) TIM3_SR_CC4IF(x) + +#define TIM_16B_SR_CC3IF_SHIFT TIM3_SR_CC3IF_SHIFT +#define TIM_16B_SR_CC3IF_MASK TIM3_SR_CC3IF_MASK +#define TIM_16B_SR_CC3IF(x) TIM3_SR_CC3IF(x) + +#define TIM_16B_SR_CC2IF_SHIFT TIM3_SR_CC2IF_SHIFT +#define TIM_16B_SR_CC2IF_MASK TIM3_SR_CC2IF_MASK +#define TIM_16B_SR_CC2IF(x) TIM3_SR_CC2IF(x) + +#define TIM_16B_SR_CC1IF_SHIFT TIM3_SR_CC1IF_SHIFT +#define TIM_16B_SR_CC1IF_MASK TIM3_SR_CC1IF_MASK +#define TIM_16B_SR_CC1IF(x) TIM3_SR_CC1IF(x) + +#define TIM_16B_SR_UIF_SHIFT TIM3_SR_UIF_SHIFT +#define TIM_16B_SR_UIF_MASK TIM3_SR_UIF_MASK +#define TIM_16B_SR_UIF(x) TIM3_SR_UIF(x) + +/*! + * @brief TIM_16B_EGR Register Bit Definition + */ + +#define TIM_16B_EGR_TG_SHIFT TIM3_EGR_TG_SHIFT +#define TIM_16B_EGR_TG_MASK TIM3_EGR_TG_MASK +#define TIM_16B_EGR_TG(x) TIM3_EGR_TG(x) + +#define TIM_16B_EGR_COMG_SHIFT TIM3_EGR_COMG_SHIFT +#define TIM_16B_EGR_COMG_MASK TIM3_EGR_COMG_MASK +#define TIM_16B_EGR_COMG(x) TIM3_EGR_COMG(x) + +#define TIM_16B_EGR_CC4G_SHIFT TIM3_EGR_CC4G_SHIFT +#define TIM_16B_EGR_CC4G_MASK TIM3_EGR_CC4G_MASK +#define TIM_16B_EGR_CC4G(x) TIM3_EGR_CC4G(x) + +#define TIM_16B_EGR_CC3G_SHIFT TIM3_EGR_CC3G_SHIFT +#define TIM_16B_EGR_CC3G_MASK TIM3_EGR_CC3G_MASK +#define TIM_16B_EGR_CC3G(x) TIM3_EGR_CC3G(x) + +#define TIM_16B_EGR_CC2G_SHIFT TIM3_EGR_CC2G_SHIFT +#define TIM_16B_EGR_CC2G_MASK TIM3_EGR_CC2G_MASK +#define TIM_16B_EGR_CC2G(x) TIM3_EGR_CC2G(x) + +#define TIM_16B_EGR_CC1G_SHIFT TIM3_EGR_CC1G_SHIFT +#define TIM_16B_EGR_CC1G_MASK TIM3_EGR_CC1G_MASK +#define TIM_16B_EGR_CC1G(x) TIM3_EGR_CC1G(x) + +#define TIM_16B_EGR_UG_SHIFT TIM3_EGR_UG_SHIFT +#define TIM_16B_EGR_UG_MASK TIM3_EGR_UG_MASK +#define TIM_16B_EGR_UG(x) TIM3_EGR_UG(x) + +/*! + * @brief TIM_16B_CCMR1 Register Bit Definition + */ + +#define TIM_16B_CCMR1_OC2CE_SHIFT TIM3_CCMR1_OC2CE_SHIFT +#define TIM_16B_CCMR1_OC2CE_MASK TIM3_CCMR1_OC2CE_MASK +#define TIM_16B_CCMR1_OC2CE(x) TIM3_CCMR1_OC2CE(x) + +#define TIM_16B_CCMR1_OC2M_SHIFT TIM3_CCMR1_OC2M_SHIFT +#define TIM_16B_CCMR1_OC2M_MASK TIM3_CCMR1_OC2M_MASK +#define TIM_16B_CCMR1_OC2M(x) TIM3_CCMR1_OC2M(x) + +#define TIM_16B_CCMR1_OC2PE_SHIFT TIM3_CCMR1_OC2PE_SHIFT +#define TIM_16B_CCMR1_OC2PE_MASK TIM3_CCMR1_OC2PE_MASK +#define TIM_16B_CCMR1_OC2PE(x) TIM3_CCMR1_OC2PE(x) + +#define TIM_16B_CCMR1_OC2FE_SHIFT TIM3_CCMR1_OC2FE_SHIFT +#define TIM_16B_CCMR1_OC2FE_MASK TIM3_CCMR1_OC2FE_MASK +#define TIM_16B_CCMR1_OC2FE(x) TIM3_CCMR1_OC2FE(x) + +#define TIM_16B_CCMR1_CC2S_SHIFT TIM3_CCMR1_CC2S_SHIFT +#define TIM_16B_CCMR1_CC2S_MASK TIM3_CCMR1_CC2S_MASK +#define TIM_16B_CCMR1_CC2S(x) TIM3_CCMR1_CC2S(x) + +#define TIM_16B_CCMR1_OC1CE_SHIFT TIM3_CCMR1_OC1CE_SHIFT +#define TIM_16B_CCMR1_OC1CE_MASK TIM3_CCMR1_OC1CE_MASK +#define TIM_16B_CCMR1_OC1CE(x) TIM3_CCMR1_OC1CE(x) + +#define TIM_16B_CCMR1_OC1M_SHIFT TIM3_CCMR1_OC1M_SHIFT +#define TIM_16B_CCMR1_OC1M_MASK TIM3_CCMR1_OC1M_MASK +#define TIM_16B_CCMR1_OC1M(x) TIM3_CCMR1_OC1M(x) + +#define TIM_16B_CCMR1_OC1PE_SHIFT TIM3_CCMR1_OC1PE_SHIFT +#define TIM_16B_CCMR1_OC1PE_MASK TIM3_CCMR1_OC1PE_MASK +#define TIM_16B_CCMR1_OC1PE(x) TIM3_CCMR1_OC1PE(x) + +#define TIM_16B_CCMR1_OC1FE_SHIFT TIM3_CCMR1_OC1FE_SHIFT +#define TIM_16B_CCMR1_OC1FE_MASK TIM3_CCMR1_OC1FE_MASK +#define TIM_16B_CCMR1_OC1FE(x) TIM3_CCMR1_OC1FE(x) + +#define TIM_16B_CCMR1_CC1S_SHIFT TIM3_CCMR1_CC1S_SHIFT +#define TIM_16B_CCMR1_CC1S_MASK TIM3_CCMR1_CC1S_MASK +#define TIM_16B_CCMR1_CC1S(x) TIM3_CCMR1_CC1S(x) + +/*! + * @brief TIM_16B_CCMR1 Register Bit Definition + */ + +#define TIM_16B_CCMR1_IC2F_SHIFT TIM3_CCMR1_IC2F_SHIFT +#define TIM_16B_CCMR1_IC2F_MASK TIM3_CCMR1_IC2F_MASK +#define TIM_16B_CCMR1_IC2F(x) TIM3_CCMR1_IC2F(x) + +#define TIM_16B_CCMR1_IC2PSC_SHIFT TIM3_CCMR1_IC2PSC_SHIFT +#define TIM_16B_CCMR1_IC2PSC_MASK TIM3_CCMR1_IC2PSC_MASK +#define TIM_16B_CCMR1_IC2PSC(x) TIM3_CCMR1_IC2PSC(x) + +#define TIM_16B_CCMR1_CC2S_SHIFT TIM3_CCMR1_CC2S_SHIFT +#define TIM_16B_CCMR1_CC2S_MASK TIM3_CCMR1_CC2S_MASK +#define TIM_16B_CCMR1_CC2S(x) TIM3_CCMR1_CC2S(x) + +#define TIM_16B_CCMR1_IC1F_SHIFT TIM3_CCMR1_IC1F_SHIFT +#define TIM_16B_CCMR1_IC1F_MASK TIM3_CCMR1_IC1F_MASK +#define TIM_16B_CCMR1_IC1F(x) TIM3_CCMR1_IC1F(x) + +#define TIM_16B_CCMR1_IC1PSC_SHIFT TIM3_CCMR1_IC1PSC_SHIFT +#define TIM_16B_CCMR1_IC1PSC_MASK TIM3_CCMR1_IC1PSC_MASK +#define TIM_16B_CCMR1_IC1PSC(x) TIM3_CCMR1_IC1PSC(x) + +#define TIM_16B_CCMR1_CC1S_SHIFT TIM3_CCMR1_CC1S_SHIFT +#define TIM_16B_CCMR1_CC1S_MASK TIM3_CCMR1_CC1S_MASK +#define TIM_16B_CCMR1_CC1S(x) TIM3_CCMR1_CC1S(x) + +/*! + * @brief TIM_16B_CCMR2 Register Bit Definition + */ + +#define TIM_16B_CCMR2_OC4CE_SHIFT TIM3_CCMR2_OC4CE_SHIFT +#define TIM_16B_CCMR2_OC4CE_MASK TIM3_CCMR2_OC4CE_MASK +#define TIM_16B_CCMR2_OC4CE(x) TIM3_CCMR2_OC4CE(x) + +#define TIM_16B_CCMR2_OC4M_SHIFT TIM3_CCMR2_OC4M_SHIFT +#define TIM_16B_CCMR2_OC4M_MASK TIM3_CCMR2_OC4M_MASK +#define TIM_16B_CCMR2_OC4M(x) TIM3_CCMR2_OC4M(x) + +#define TIM_16B_CCMR2_OC4PE_SHIFT TIM3_CCMR2_OC4PE_SHIFT +#define TIM_16B_CCMR2_OC4PE_MASK TIM3_CCMR2_OC4PE_MASK +#define TIM_16B_CCMR2_OC4PE(x) TIM3_CCMR2_OC4PE(x) + +#define TIM_16B_CCMR2_OC4FE_SHIFT TIM3_CCMR2_OC4FE_SHIFT +#define TIM_16B_CCMR2_OC4FE_MASK TIM3_CCMR2_OC4FE_MASK +#define TIM_16B_CCMR2_OC4FE(x) TIM3_CCMR2_OC4FE(x) + +#define TIM_16B_CCMR2_CC4S_SHIFT TIM3_CCMR2_CC4S_SHIFT +#define TIM_16B_CCMR2_CC4S_MASK TIM3_CCMR2_CC4S_MASK +#define TIM_16B_CCMR2_CC4S(x) TIM3_CCMR2_CC4S(x) + +#define TIM_16B_CCMR2_OC3CE_SHIFT TIM3_CCMR2_OC3CE_SHIFT +#define TIM_16B_CCMR2_OC3CE_MASK TIM3_CCMR2_OC3CE_MASK +#define TIM_16B_CCMR2_OC3CE(x) TIM3_CCMR2_OC3CE(x) + +#define TIM_16B_CCMR2_OC3M_SHIFT TIM3_CCMR2_OC3M_SHIFT +#define TIM_16B_CCMR2_OC3M_MASK TIM3_CCMR2_OC3M_MASK +#define TIM_16B_CCMR2_OC3M(x) TIM3_CCMR2_OC3M(x) + +#define TIM_16B_CCMR2_OC3PE_SHIFT TIM3_CCMR2_OC3PE_SHIFT +#define TIM_16B_CCMR2_OC3PE_MASK TIM3_CCMR2_OC3PE_MASK +#define TIM_16B_CCMR2_OC3PE(x) TIM3_CCMR2_OC3PE(x) + +#define TIM_16B_CCMR2_OC3FE_SHIFT TIM3_CCMR2_OC3FE_SHIFT +#define TIM_16B_CCMR2_OC3FE_MASK TIM3_CCMR2_OC3FE_MASK +#define TIM_16B_CCMR2_OC3FE(x) TIM3_CCMR2_OC3FE(x) + +#define TIM_16B_CCMR2_CC3S_SHIFT TIM3_CCMR2_CC3S_SHIFT +#define TIM_16B_CCMR2_CC3S_MASK TIM3_CCMR2_CC3S_MASK +#define TIM_16B_CCMR2_CC3S(x) TIM3_CCMR2_CC3S(x) + +/*! + * @brief TIM_16B_CCMR2 Register Bit Definition + */ + +#define TIM_16B_CCMR2_IC4F_SHIFT TIM3_CCMR2_IC4F_SHIFT +#define TIM_16B_CCMR2_IC4F_MASK TIM3_CCMR2_IC4F_MASK +#define TIM_16B_CCMR2_IC4F(x) TIM3_CCMR2_IC4F(x) + +#define TIM_16B_CCMR2_IC4PSC_SHIFT TIM3_CCMR2_IC4PSC_SHIFT +#define TIM_16B_CCMR2_IC4PSC_MASK TIM3_CCMR2_IC4PSC_MASK +#define TIM_16B_CCMR2_IC4PSC(x) TIM3_CCMR2_IC4PSC(x) + +#define TIM_16B_CCMR2_CC4S_SHIFT TIM3_CCMR2_CC4S_SHIFT +#define TIM_16B_CCMR2_CC4S_MASK TIM3_CCMR2_CC4S_MASK +#define TIM_16B_CCMR2_CC4S(x) TIM3_CCMR2_CC4S(x) + +#define TIM_16B_CCMR2_IC3F_SHIFT TIM3_CCMR2_IC3F_SHIFT +#define TIM_16B_CCMR2_IC3F_MASK TIM3_CCMR2_IC3F_MASK +#define TIM_16B_CCMR2_IC3F(x) TIM3_CCMR2_IC3F(x) + +#define TIM_16B_CCMR2_IC3PSC_SHIFT TIM3_CCMR2_IC3PSC_SHIFT +#define TIM_16B_CCMR2_IC3PSC_MASK TIM3_CCMR2_IC3PSC_MASK +#define TIM_16B_CCMR2_IC3PSC(x) TIM3_CCMR2_IC3PSC(x) + +#define TIM_16B_CCMR2_CC3S_SHIFT TIM3_CCMR2_CC3S_SHIFT +#define TIM_16B_CCMR2_CC3S_MASK TIM3_CCMR2_CC3S_MASK +#define TIM_16B_CCMR2_CC3S(x) TIM3_CCMR2_CC3S(x) + +/*! + * @brief TIM_16B_CCER Register Bit Definition + */ + +#define TIM_16B_CCER_CC4NP_SHIFT TIM3_CCER_CC4NP_SHIFT +#define TIM_16B_CCER_CC4NP_MASK TIM3_CCER_CC4NP_MASK +#define TIM_16B_CCER_CC4NP(x) TIM3_CCER_CC4NP(x) + +#define TIM_16B_CCER_CC4P_SHIFT TIM3_CCER_CC4P_SHIFT +#define TIM_16B_CCER_CC4P_MASK TIM3_CCER_CC4P_MASK +#define TIM_16B_CCER_CC4P(x) TIM3_CCER_CC4P(x) + +#define TIM_16B_CCER_CC4E_SHIFT TIM3_CCER_CC4E_SHIFT +#define TIM_16B_CCER_CC4E_MASK TIM3_CCER_CC4E_MASK +#define TIM_16B_CCER_CC4E(x) TIM3_CCER_CC4E(x) + +#define TIM_16B_CCER_CC3NP_SHIFT TIM3_CCER_CC3NP_SHIFT +#define TIM_16B_CCER_CC3NP_MASK TIM3_CCER_CC3NP_MASK +#define TIM_16B_CCER_CC3NP(x) TIM3_CCER_CC3NP(x) + +#define TIM_16B_CCER_CC3P_SHIFT TIM3_CCER_CC3P_SHIFT +#define TIM_16B_CCER_CC3P_MASK TIM3_CCER_CC3P_MASK +#define TIM_16B_CCER_CC3P(x) TIM3_CCER_CC3P(x) + +#define TIM_16B_CCER_CC3E_SHIFT TIM3_CCER_CC3E_SHIFT +#define TIM_16B_CCER_CC3E_MASK TIM3_CCER_CC3E_MASK +#define TIM_16B_CCER_CC3E(x) TIM3_CCER_CC3E(x) + +#define TIM_16B_CCER_CC2NP_SHIFT TIM3_CCER_CC2NP_SHIFT +#define TIM_16B_CCER_CC2NP_MASK TIM3_CCER_CC2NP_MASK +#define TIM_16B_CCER_CC2NP(x) TIM3_CCER_CC2NP(x) + +#define TIM_16B_CCER_CC2P_SHIFT TIM3_CCER_CC2P_SHIFT +#define TIM_16B_CCER_CC2P_MASK TIM3_CCER_CC2P_MASK +#define TIM_16B_CCER_CC2P(x) TIM3_CCER_CC2P(x) + +#define TIM_16B_CCER_CC2E_SHIFT TIM3_CCER_CC2E_SHIFT +#define TIM_16B_CCER_CC2E_MASK TIM3_CCER_CC2E_MASK +#define TIM_16B_CCER_CC2E(x) TIM3_CCER_CC2E(x) + +#define TIM_16B_CCER_CC1NP_SHIFT TIM3_CCER_CC1NP_SHIFT +#define TIM_16B_CCER_CC1NP_MASK TIM3_CCER_CC1NP_MASK +#define TIM_16B_CCER_CC1NP(x) TIM3_CCER_CC1NP(x) + +#define TIM_16B_CCER_CC1P_SHIFT TIM3_CCER_CC1P_SHIFT +#define TIM_16B_CCER_CC1P_MASK TIM3_CCER_CC1P_MASK +#define TIM_16B_CCER_CC1P(x) TIM3_CCER_CC1P(x) + +#define TIM_16B_CCER_CC1E_SHIFT TIM3_CCER_CC1E_SHIFT +#define TIM_16B_CCER_CC1E_MASK TIM3_CCER_CC1E_MASK +#define TIM_16B_CCER_CC1E(x) TIM3_CCER_CC1E(x) + +/*! + * @brief TIM_16B_CNT Register Bit Definition + */ + +#define TIM_16B_CNT_CNT_SHIFT TIM3_CNT_CNT_SHIFT +#define TIM_16B_CNT_CNT_MASK TIM3_CNT_CNT_MASK +#define TIM_16B_CNT_CNT(x) TIM3_CNT_CNT(x) + +/*! + * @brief TIM_16B_PSC Register Bit Definition + */ + +#define TIM_16B_PSC_PSC_SHIFT TIM3_PSC_PSC_SHIFT +#define TIM_16B_PSC_PSC_MASK TIM3_PSC_PSC_MASK +#define TIM_16B_PSC_PSC(x) TIM3_PSC_PSC(x) + +/*! + * @brief TIM_16B_ARR Register Bit Definition + */ + +#define TIM_16B_ARR_ARR_SHIFT TIM3_ARR_ARR_SHIFT +#define TIM_16B_ARR_ARR_MASK TIM3_ARR_ARR_MASK +#define TIM_16B_ARR_ARR(x) TIM3_ARR_ARR(x) + +/*! + * @brief TIM_16B_CCR1 Register Bit Definition + */ + +#define TIM_16B_CCR1_CCR1_SHIFT TIM3_CCR1_CCR1_SHIFT +#define TIM_16B_CCR1_CCR1_MASK TIM3_CCR1_CCR1_MASK +#define TIM_16B_CCR1_CCR1(x) TIM3_CCR1_CCR1(x) + +/*! + * @brief TIM_16B_CCR2 Register Bit Definition + */ + +#define TIM_16B_CCR2_CCR2_SHIFT TIM3_CCR2_CCR2_SHIFT +#define TIM_16B_CCR2_CCR2_MASK TIM3_CCR2_CCR2_MASK +#define TIM_16B_CCR2_CCR2(x) TIM3_CCR2_CCR2(x) + +/*! + * @brief TIM_16B_CCR3 Register Bit Definition + */ + +#define TIM_16B_CCR3_CCR3_SHIFT TIM3_CCR3_CCR3_SHIFT +#define TIM_16B_CCR3_CCR3_MASK TIM3_CCR3_CCR3_MASK +#define TIM_16B_CCR3_CCR3(x) TIM3_CCR3_CCR3(x) + +/*! + * @brief TIM_16B_CCR4 Register Bit Definition + */ + +#define TIM_16B_CCR4_CCR4_SHIFT TIM3_CCR4_CCR4_SHIFT +#define TIM_16B_CCR4_CCR4_MASK TIM3_CCR4_CCR4_MASK +#define TIM_16B_CCR4_CCR4(x) TIM3_CCR4_CCR4(x) + +/*! + * @brief TIM_16B_DCR Register Bit Definition + */ + +#define TIM_16B_DCR_DBL_SHIFT TIM3_DCR_DBL_SHIFT +#define TIM_16B_DCR_DBL_MASK TIM3_DCR_DBL_MASK +#define TIM_16B_DCR_DBL(x) TIM3_DCR_DBL(x) + +#define TIM_16B_DCR_DBA_SHIFT TIM3_DCR_DBA_SHIFT +#define TIM_16B_DCR_DBA_MASK TIM3_DCR_DBA_MASK +#define TIM_16B_DCR_DBA(x) TIM3_DCR_DBA(x) + +/*! + * @brief TIM_16B_DMAR Register Bit Definition + */ + +#define TIM_16B_DMAR_DMAB_SHIFT TIM3_DMAR_DMAB_SHIFT +#define TIM_16B_DMAR_DMAB_MASK TIM3_DMAR_DMAB_MASK +#define TIM_16B_DMAR_DMAB(x) TIM3_DMAR_DMAB(x) + +/*! + * @} + */ /* end of group TIM_16B_Register_Masks */ + +/******************************************************************************* + * TIM_32B Type + ******************************************************************************/ +/*! + * @addtogroup TIM_32B_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM_32B_CR1 Register Bit Definition + */ + +#define TIM_32B_CR1_CKD_SHIFT TIM2_CR1_CKD_SHIFT +#define TIM_32B_CR1_CKD_MASK TIM2_CR1_CKD_MASK +#define TIM_32B_CR1_CKD(x) TIM2_CR1_CKD(x) + +#define TIM_32B_CR1_APRE_SHIFT TIM2_CR1_APRE_SHIFT +#define TIM_32B_CR1_APRE_MASK TIM2_CR1_APRE_MASK +#define TIM_32B_CR1_APRE(x) TIM2_CR1_APRE(x) + +#define TIM_32B_CR1_CMS_SHIFT TIM2_CR1_CMS_SHIFT +#define TIM_32B_CR1_CMS_MASK TIM2_CR1_CMS_MASK +#define TIM_32B_CR1_CMS(x) TIM2_CR1_CMS(x) + +#define TIM_32B_CR1_DIR_SHIFT TIM2_CR1_DIR_SHIFT +#define TIM_32B_CR1_DIR_MASK TIM2_CR1_DIR_MASK +#define TIM_32B_CR1_DIR(x) TIM2_CR1_DIR(x) + +#define TIM_32B_CR1_OPM_SHIFT TIM2_CR1_OPM_SHIFT +#define TIM_32B_CR1_OPM_MASK TIM2_CR1_OPM_MASK +#define TIM_32B_CR1_OPM(x) TIM2_CR1_OPM(x) + +#define TIM_32B_CR1_URS_SHIFT TIM2_CR1_URS_SHIFT +#define TIM_32B_CR1_URS_MASK TIM2_CR1_URS_MASK +#define TIM_32B_CR1_URS(x) TIM2_CR1_URS(x) + +#define TIM_32B_CR1_UDIS_SHIFT TIM2_CR1_UDIS_SHIFT +#define TIM_32B_CR1_UDIS_MASK TIM2_CR1_UDIS_MASK +#define TIM_32B_CR1_UDIS(x) TIM2_CR1_UDIS(x) + +#define TIM_32B_CR1_CEN_SHIFT TIM2_CR1_CEN_SHIFT +#define TIM_32B_CR1_CEN_MASK TIM2_CR1_CEN_MASK +#define TIM_32B_CR1_CEN(x) TIM2_CR1_CEN(x) + +/*! + * @brief TIM_32B_CR2 Register Bit Definition + */ + +#define TIM_32B_CR2_TI1S_SHIFT TIM2_CR2_TI1S_SHIFT +#define TIM_32B_CR2_TI1S_MASK TIM2_CR2_TI1S_MASK +#define TIM_32B_CR2_TI1S(x) TIM2_CR2_TI1S(x) + +#define TIM_32B_CR2_MMS_SHIFT TIM2_CR2_MMS_SHIFT +#define TIM_32B_CR2_MMS_MASK TIM2_CR2_MMS_MASK +#define TIM_32B_CR2_MMS(x) TIM2_CR2_MMS(x) + +#define TIM_32B_CR2_CCDS_SHIFT TIM2_CR2_CCDS_SHIFT +#define TIM_32B_CR2_CCDS_MASK TIM2_CR2_CCDS_MASK +#define TIM_32B_CR2_CCDS(x) TIM2_CR2_CCDS(x) + +/*! + * @brief TIM_32B_SMCR Register Bit Definition + */ + +#define TIM_32B_SMCR_ETP_SHIFT TIM2_SMCR_ETP_SHIFT +#define TIM_32B_SMCR_ETP_MASK TIM2_SMCR_ETP_MASK +#define TIM_32B_SMCR_ETP(x) TIM2_SMCR_ETP(x) + +#define TIM_32B_SMCR_ECE_SHIFT TIM2_SMCR_ECE_SHIFT +#define TIM_32B_SMCR_ECE_MASK TIM2_SMCR_ECE_MASK +#define TIM_32B_SMCR_ECE(x) TIM2_SMCR_ECE(x) + +#define TIM_32B_SMCR_ETPS_SHIFT TIM2_SMCR_ETPS_SHIFT +#define TIM_32B_SMCR_ETPS_MASK TIM2_SMCR_ETPS_MASK +#define TIM_32B_SMCR_ETPS(x) TIM2_SMCR_ETPS(x) + +#define TIM_32B_SMCR_ETF_SHIFT TIM2_SMCR_ETF_SHIFT +#define TIM_32B_SMCR_ETF_MASK TIM2_SMCR_ETF_MASK +#define TIM_32B_SMCR_ETF(x) TIM2_SMCR_ETF(x) + +#define TIM_32B_SMCR_MSM_SHIFT TIM2_SMCR_MSM_SHIFT +#define TIM_32B_SMCR_MSM_MASK TIM2_SMCR_MSM_MASK +#define TIM_32B_SMCR_MSM(x) TIM2_SMCR_MSM(x) + +#define TIM_32B_SMCR_TS_SHIFT TIM2_SMCR_TS_SHIFT +#define TIM_32B_SMCR_TS_MASK TIM2_SMCR_TS_MASK +#define TIM_32B_SMCR_TS(x) TIM2_SMCR_TS(x) + +#define TIM_32B_SMCR_OCCS_SHIFT TIM2_SMCR_OCCS_SHIFT +#define TIM_32B_SMCR_OCCS_MASK TIM2_SMCR_OCCS_MASK +#define TIM_32B_SMCR_OCCS(x) TIM2_SMCR_OCCS(x) + +#define TIM_32B_SMCR_SMS_SHIFT TIM2_SMCR_SMS_SHIFT +#define TIM_32B_SMCR_SMS_MASK TIM2_SMCR_SMS_MASK +#define TIM_32B_SMCR_SMS(x) TIM2_SMCR_SMS(x) + +/*! + * @brief TIM_32B_DIER Register Bit Definition + */ + +#define TIM_32B_DIER_TDE_SHIFT TIM2_DIER_TDE_SHIFT +#define TIM_32B_DIER_TDE_MASK TIM2_DIER_TDE_MASK +#define TIM_32B_DIER_TDE(x) TIM2_DIER_TDE(x) + +#define TIM_32B_DIER_CC4DE_SHIFT TIM2_DIER_CC4DE_SHIFT +#define TIM_32B_DIER_CC4DE_MASK TIM2_DIER_CC4DE_MASK +#define TIM_32B_DIER_CC4DE(x) TIM2_DIER_CC4DE(x) + +#define TIM_32B_DIER_CC3DE_SHIFT TIM2_DIER_CC3DE_SHIFT +#define TIM_32B_DIER_CC3DE_MASK TIM2_DIER_CC3DE_MASK +#define TIM_32B_DIER_CC3DE(x) TIM2_DIER_CC3DE(x) + +#define TIM_32B_DIER_CC2DE_SHIFT TIM2_DIER_CC2DE_SHIFT +#define TIM_32B_DIER_CC2DE_MASK TIM2_DIER_CC2DE_MASK +#define TIM_32B_DIER_CC2DE(x) TIM2_DIER_CC2DE(x) + +#define TIM_32B_DIER_CC1DE_SHIFT TIM2_DIER_CC1DE_SHIFT +#define TIM_32B_DIER_CC1DE_MASK TIM2_DIER_CC1DE_MASK +#define TIM_32B_DIER_CC1DE(x) TIM2_DIER_CC1DE(x) + +#define TIM_32B_DIER_UDE_SHIFT TIM2_DIER_UDE_SHIFT +#define TIM_32B_DIER_UDE_MASK TIM2_DIER_UDE_MASK +#define TIM_32B_DIER_UDE(x) TIM2_DIER_UDE(x) + +#define TIM_32B_DIER_TIE_SHIFT TIM2_DIER_TIE_SHIFT +#define TIM_32B_DIER_TIE_MASK TIM2_DIER_TIE_MASK +#define TIM_32B_DIER_TIE(x) TIM2_DIER_TIE(x) + +#define TIM_32B_DIER_CC4IE_SHIFT TIM2_DIER_CC4IE_SHIFT +#define TIM_32B_DIER_CC4IE_MASK TIM2_DIER_CC4IE_MASK +#define TIM_32B_DIER_CC4IE(x) TIM2_DIER_CC4IE(x) + +#define TIM_32B_DIER_CC3IE_SHIFT TIM2_DIER_CC3IE_SHIFT +#define TIM_32B_DIER_CC3IE_MASK TIM2_DIER_CC3IE_MASK +#define TIM_32B_DIER_CC3IE(x) TIM2_DIER_CC3IE(x) + +#define TIM_32B_DIER_CC2IE_SHIFT TIM2_DIER_CC2IE_SHIFT +#define TIM_32B_DIER_CC2IE_MASK TIM2_DIER_CC2IE_MASK +#define TIM_32B_DIER_CC2IE(x) TIM2_DIER_CC2IE(x) + +#define TIM_32B_DIER_CC1IE_SHIFT TIM2_DIER_CC1IE_SHIFT +#define TIM_32B_DIER_CC1IE_MASK TIM2_DIER_CC1IE_MASK +#define TIM_32B_DIER_CC1IE(x) TIM2_DIER_CC1IE(x) + +#define TIM_32B_DIER_UIE_SHIFT TIM2_DIER_UIE_SHIFT +#define TIM_32B_DIER_UIE_MASK TIM2_DIER_UIE_MASK +#define TIM_32B_DIER_UIE(x) TIM2_DIER_UIE(x) + +/*! + * @brief TIM_32B_SR Register Bit Definition + */ + +#define TIM_32B_SR_CC4OF_SHIFT TIM2_SR_CC4OF_SHIFT +#define TIM_32B_SR_CC4OF_MASK TIM2_SR_CC4OF_MASK +#define TIM_32B_SR_CC4OF(x) TIM2_SR_CC4OF(x) + +#define TIM_32B_SR_CC3OF_SHIFT TIM2_SR_CC3OF_SHIFT +#define TIM_32B_SR_CC3OF_MASK TIM2_SR_CC3OF_MASK +#define TIM_32B_SR_CC3OF(x) TIM2_SR_CC3OF(x) + +#define TIM_32B_SR_CC2OF_SHIFT TIM2_SR_CC2OF_SHIFT +#define TIM_32B_SR_CC2OF_MASK TIM2_SR_CC2OF_MASK +#define TIM_32B_SR_CC2OF(x) TIM2_SR_CC2OF(x) + +#define TIM_32B_SR_CC1OF_SHIFT TIM2_SR_CC1OF_SHIFT +#define TIM_32B_SR_CC1OF_MASK TIM2_SR_CC1OF_MASK +#define TIM_32B_SR_CC1OF(x) TIM2_SR_CC1OF(x) + +#define TIM_32B_SR_TIF_SHIFT TIM2_SR_TIF_SHIFT +#define TIM_32B_SR_TIF_MASK TIM2_SR_TIF_MASK +#define TIM_32B_SR_TIF(x) TIM2_SR_TIF(x) + +#define TIM_32B_SR_CC4IF_SHIFT TIM2_SR_CC4IF_SHIFT +#define TIM_32B_SR_CC4IF_MASK TIM2_SR_CC4IF_MASK +#define TIM_32B_SR_CC4IF(x) TIM2_SR_CC4IF(x) + +#define TIM_32B_SR_CC3IF_SHIFT TIM2_SR_CC3IF_SHIFT +#define TIM_32B_SR_CC3IF_MASK TIM2_SR_CC3IF_MASK +#define TIM_32B_SR_CC3IF(x) TIM2_SR_CC3IF(x) + +#define TIM_32B_SR_CC2IF_SHIFT TIM2_SR_CC2IF_SHIFT +#define TIM_32B_SR_CC2IF_MASK TIM2_SR_CC2IF_MASK +#define TIM_32B_SR_CC2IF(x) TIM2_SR_CC2IF(x) + +#define TIM_32B_SR_CC1IF_SHIFT TIM2_SR_CC1IF_SHIFT +#define TIM_32B_SR_CC1IF_MASK TIM2_SR_CC1IF_MASK +#define TIM_32B_SR_CC1IF(x) TIM2_SR_CC1IF(x) + +#define TIM_32B_SR_UIF_SHIFT TIM2_SR_UIF_SHIFT +#define TIM_32B_SR_UIF_MASK TIM2_SR_UIF_MASK +#define TIM_32B_SR_UIF(x) TIM2_SR_UIF(x) + +/*! + * @brief TIM_32B_EGR Register Bit Definition + */ + +#define TIM_32B_EGR_TG_SHIFT TIM2_EGR_TG_SHIFT +#define TIM_32B_EGR_TG_MASK TIM2_EGR_TG_MASK +#define TIM_32B_EGR_TG(x) TIM2_EGR_TG(x) + +#define TIM_32B_EGR_COMG_SHIFT TIM2_EGR_COMG_SHIFT +#define TIM_32B_EGR_COMG_MASK TIM2_EGR_COMG_MASK +#define TIM_32B_EGR_COMG(x) TIM2_EGR_COMG(x) + +#define TIM_32B_EGR_CC4G_SHIFT TIM2_EGR_CC4G_SHIFT +#define TIM_32B_EGR_CC4G_MASK TIM2_EGR_CC4G_MASK +#define TIM_32B_EGR_CC4G(x) TIM2_EGR_CC4G(x) + +#define TIM_32B_EGR_CC3G_SHIFT TIM2_EGR_CC3G_SHIFT +#define TIM_32B_EGR_CC3G_MASK TIM2_EGR_CC3G_MASK +#define TIM_32B_EGR_CC3G(x) TIM2_EGR_CC3G(x) + +#define TIM_32B_EGR_CC2G_SHIFT TIM2_EGR_CC2G_SHIFT +#define TIM_32B_EGR_CC2G_MASK TIM2_EGR_CC2G_MASK +#define TIM_32B_EGR_CC2G(x) TIM2_EGR_CC2G(x) + +#define TIM_32B_EGR_CC1G_SHIFT TIM2_EGR_CC1G_SHIFT +#define TIM_32B_EGR_CC1G_MASK TIM2_EGR_CC1G_MASK +#define TIM_32B_EGR_CC1G(x) TIM2_EGR_CC1G(x) + +#define TIM_32B_EGR_UG_SHIFT TIM2_EGR_UG_SHIFT +#define TIM_32B_EGR_UG_MASK TIM2_EGR_UG_MASK +#define TIM_32B_EGR_UG(x) TIM2_EGR_UG(x) + +/*! + * @brief TIM_32B_CCMR1 Register Bit Definition + */ + +#define TIM_32B_CCMR1_OC2CE_SHIFT TIM2_CCMR1_OC2CE_SHIFT +#define TIM_32B_CCMR1_OC2CE_MASK TIM2_CCMR1_OC2CE_MASK +#define TIM_32B_CCMR1_OC2CE(x) TIM2_CCMR1_OC2CE(x) + +#define TIM_32B_CCMR1_OC2M_SHIFT TIM2_CCMR1_OC2M_SHIFT +#define TIM_32B_CCMR1_OC2M_MASK TIM2_CCMR1_OC2M_MASK +#define TIM_32B_CCMR1_OC2M(x) TIM2_CCMR1_OC2M(x) + +#define TIM_32B_CCMR1_OC2PE_SHIFT TIM2_CCMR1_OC2PE_SHIFT +#define TIM_32B_CCMR1_OC2PE_MASK TIM2_CCMR1_OC2PE_MASK +#define TIM_32B_CCMR1_OC2PE(x) TIM2_CCMR1_OC2PE(x) + +#define TIM_32B_CCMR1_OC2FE_SHIFT TIM2_CCMR1_OC2FE_SHIFT +#define TIM_32B_CCMR1_OC2FE_MASK TIM2_CCMR1_OC2FE_MASK +#define TIM_32B_CCMR1_OC2FE(x) TIM2_CCMR1_OC2FE(x) + +#define TIM_32B_CCMR1_CC2S_SHIFT TIM2_CCMR1_CC2S_SHIFT +#define TIM_32B_CCMR1_CC2S_MASK TIM2_CCMR1_CC2S_MASK +#define TIM_32B_CCMR1_CC2S(x) TIM2_CCMR1_CC2S(x) + +#define TIM_32B_CCMR1_OC1CE_SHIFT TIM2_CCMR1_OC1CE_SHIFT +#define TIM_32B_CCMR1_OC1CE_MASK TIM2_CCMR1_OC1CE_MASK +#define TIM_32B_CCMR1_OC1CE(x) TIM2_CCMR1_OC1CE(x) + +#define TIM_32B_CCMR1_OC1M_SHIFT TIM2_CCMR1_OC1M_SHIFT +#define TIM_32B_CCMR1_OC1M_MASK TIM2_CCMR1_OC1M_MASK +#define TIM_32B_CCMR1_OC1M(x) TIM2_CCMR1_OC1M(x) + +#define TIM_32B_CCMR1_OC1PE_SHIFT TIM2_CCMR1_OC1PE_SHIFT +#define TIM_32B_CCMR1_OC1PE_MASK TIM2_CCMR1_OC1PE_MASK +#define TIM_32B_CCMR1_OC1PE(x) TIM2_CCMR1_OC1PE(x) + +#define TIM_32B_CCMR1_OC1FE_SHIFT TIM2_CCMR1_OC1FE_SHIFT +#define TIM_32B_CCMR1_OC1FE_MASK TIM2_CCMR1_OC1FE_MASK +#define TIM_32B_CCMR1_OC1FE(x) TIM2_CCMR1_OC1FE(x) + +#define TIM_32B_CCMR1_CC1S_SHIFT TIM2_CCMR1_CC1S_SHIFT +#define TIM_32B_CCMR1_CC1S_MASK TIM2_CCMR1_CC1S_MASK +#define TIM_32B_CCMR1_CC1S(x) TIM2_CCMR1_CC1S(x) + +/*! + * @brief TIM_32B_CCMR1 Register Bit Definition + */ + +#define TIM_32B_CCMR1_IC2F_SHIFT TIM2_CCMR1_IC2F_SHIFT +#define TIM_32B_CCMR1_IC2F_MASK TIM2_CCMR1_IC2F_MASK +#define TIM_32B_CCMR1_IC2F(x) TIM2_CCMR1_IC2F(x) + +#define TIM_32B_CCMR1_IC2PSC_SHIFT TIM2_CCMR1_IC2PSC_SHIFT +#define TIM_32B_CCMR1_IC2PSC_MASK TIM2_CCMR1_IC2PSC_MASK +#define TIM_32B_CCMR1_IC2PSC(x) TIM2_CCMR1_IC2PSC(x) + +#define TIM_32B_CCMR1_CC2S_SHIFT TIM2_CCMR1_CC2S_SHIFT +#define TIM_32B_CCMR1_CC2S_MASK TIM2_CCMR1_CC2S_MASK +#define TIM_32B_CCMR1_CC2S(x) TIM2_CCMR1_CC2S(x) + +#define TIM_32B_CCMR1_IC1F_SHIFT TIM2_CCMR1_IC1F_SHIFT +#define TIM_32B_CCMR1_IC1F_MASK TIM2_CCMR1_IC1F_MASK +#define TIM_32B_CCMR1_IC1F(x) TIM2_CCMR1_IC1F(x) + +#define TIM_32B_CCMR1_IC1PSC_SHIFT TIM2_CCMR1_IC1PSC_SHIFT +#define TIM_32B_CCMR1_IC1PSC_MASK TIM2_CCMR1_IC1PSC_MASK +#define TIM_32B_CCMR1_IC1PSC(x) TIM2_CCMR1_IC1PSC(x) + +#define TIM_32B_CCMR1_CC1S_SHIFT TIM2_CCMR1_CC1S_SHIFT +#define TIM_32B_CCMR1_CC1S_MASK TIM2_CCMR1_CC1S_MASK +#define TIM_32B_CCMR1_CC1S(x) TIM2_CCMR1_CC1S(x) + +/*! + * @brief TIM_32B_CCMR2 Register Bit Definition + */ + +#define TIM_32B_CCMR2_OC4CE_SHIFT TIM2_CCMR2_OC4CE_SHIFT +#define TIM_32B_CCMR2_OC4CE_MASK TIM2_CCMR2_OC4CE_MASK +#define TIM_32B_CCMR2_OC4CE(x) TIM2_CCMR2_OC4CE(x) + +#define TIM_32B_CCMR2_OC4M_SHIFT TIM2_CCMR2_OC4M_SHIFT +#define TIM_32B_CCMR2_OC4M_MASK TIM2_CCMR2_OC4M_MASK +#define TIM_32B_CCMR2_OC4M(x) TIM2_CCMR2_OC4M(x) + +#define TIM_32B_CCMR2_OC4PE_SHIFT TIM2_CCMR2_OC4PE_SHIFT +#define TIM_32B_CCMR2_OC4PE_MASK TIM2_CCMR2_OC4PE_MASK +#define TIM_32B_CCMR2_OC4PE(x) TIM2_CCMR2_OC4PE(x) + +#define TIM_32B_CCMR2_OC4FE_SHIFT TIM2_CCMR2_OC4FE_SHIFT +#define TIM_32B_CCMR2_OC4FE_MASK TIM2_CCMR2_OC4FE_MASK +#define TIM_32B_CCMR2_OC4FE(x) TIM2_CCMR2_OC4FE(x) + +#define TIM_32B_CCMR2_CC4S_SHIFT TIM2_CCMR2_CC4S_SHIFT +#define TIM_32B_CCMR2_CC4S_MASK TIM2_CCMR2_CC4S_MASK +#define TIM_32B_CCMR2_CC4S(x) TIM2_CCMR2_CC4S(x) + +#define TIM_32B_CCMR2_OC3CE_SHIFT TIM2_CCMR2_OC3CE_SHIFT +#define TIM_32B_CCMR2_OC3CE_MASK TIM2_CCMR2_OC3CE_MASK +#define TIM_32B_CCMR2_OC3CE(x) TIM2_CCMR2_OC3CE(x) + +#define TIM_32B_CCMR2_OC3M_SHIFT TIM2_CCMR2_OC3M_SHIFT +#define TIM_32B_CCMR2_OC3M_MASK TIM2_CCMR2_OC3M_MASK +#define TIM_32B_CCMR2_OC3M(x) TIM2_CCMR2_OC3M(x) + +#define TIM_32B_CCMR2_OC3PE_SHIFT TIM2_CCMR2_OC3PE_SHIFT +#define TIM_32B_CCMR2_OC3PE_MASK TIM2_CCMR2_OC3PE_MASK +#define TIM_32B_CCMR2_OC3PE(x) TIM2_CCMR2_OC3PE(x) + +#define TIM_32B_CCMR2_OC3FE_SHIFT TIM2_CCMR2_OC3FE_SHIFT +#define TIM_32B_CCMR2_OC3FE_MASK TIM2_CCMR2_OC3FE_MASK +#define TIM_32B_CCMR2_OC3FE(x) TIM2_CCMR2_OC3FE(x) + +#define TIM_32B_CCMR2_CC3S_SHIFT TIM2_CCMR2_CC3S_SHIFT +#define TIM_32B_CCMR2_CC3S_MASK TIM2_CCMR2_CC3S_MASK +#define TIM_32B_CCMR2_CC3S(x) TIM2_CCMR2_CC3S(x) + +/*! + * @brief TIM_32B_CCMR2 Register Bit Definition + */ + +#define TIM_32B_CCMR2_IC4F_SHIFT TIM2_CCMR2_IC4F_SHIFT +#define TIM_32B_CCMR2_IC4F_MASK TIM2_CCMR2_IC4F_MASK +#define TIM_32B_CCMR2_IC4F(x) TIM2_CCMR2_IC4F(x) + +#define TIM_32B_CCMR2_IC4PSC_SHIFT TIM2_CCMR2_IC4PSC_SHIFT +#define TIM_32B_CCMR2_IC4PSC_MASK TIM2_CCMR2_IC4PSC_MASK +#define TIM_32B_CCMR2_IC4PSC(x) TIM2_CCMR2_IC4PSC(x) + +#define TIM_32B_CCMR2_CC4S_SHIFT TIM2_CCMR2_CC4S_SHIFT +#define TIM_32B_CCMR2_CC4S_MASK TIM2_CCMR2_CC4S_MASK +#define TIM_32B_CCMR2_CC4S(x) TIM2_CCMR2_CC4S(x) + +#define TIM_32B_CCMR2_IC3F_SHIFT TIM2_CCMR2_IC3F_SHIFT +#define TIM_32B_CCMR2_IC3F_MASK TIM2_CCMR2_IC3F_MASK +#define TIM_32B_CCMR2_IC3F(x) TIM2_CCMR2_IC3F(x) + +#define TIM_32B_CCMR2_IC3PSC_SHIFT TIM2_CCMR2_IC3PSC_SHIFT +#define TIM_32B_CCMR2_IC3PSC_MASK TIM2_CCMR2_IC3PSC_MASK +#define TIM_32B_CCMR2_IC3PSC(x) TIM2_CCMR2_IC3PSC(x) + +#define TIM_32B_CCMR2_CC3S_SHIFT TIM2_CCMR2_CC3S_SHIFT +#define TIM_32B_CCMR2_CC3S_MASK TIM2_CCMR2_CC3S_MASK +#define TIM_32B_CCMR2_CC3S(x) TIM2_CCMR2_CC3S(x) + +/*! + * @brief TIM_32B_CCER Register Bit Definition + */ + +#define TIM_32B_CCER_CC4NP_SHIFT TIM2_CCER_CC4NP_SHIFT +#define TIM_32B_CCER_CC4NP_MASK TIM2_CCER_CC4NP_MASK +#define TIM_32B_CCER_CC4NP(x) TIM2_CCER_CC4NP(x) + +#define TIM_32B_CCER_CC4P_SHIFT TIM2_CCER_CC4P_SHIFT +#define TIM_32B_CCER_CC4P_MASK TIM2_CCER_CC4P_MASK +#define TIM_32B_CCER_CC4P(x) TIM2_CCER_CC4P(x) + +#define TIM_32B_CCER_CC4E_SHIFT TIM2_CCER_CC4E_SHIFT +#define TIM_32B_CCER_CC4E_MASK TIM2_CCER_CC4E_MASK +#define TIM_32B_CCER_CC4E(x) TIM2_CCER_CC4E(x) + +#define TIM_32B_CCER_CC3NP_SHIFT TIM2_CCER_CC3NP_SHIFT +#define TIM_32B_CCER_CC3NP_MASK TIM2_CCER_CC3NP_MASK +#define TIM_32B_CCER_CC3NP(x) TIM2_CCER_CC3NP(x) + +#define TIM_32B_CCER_CC3P_SHIFT TIM2_CCER_CC3P_SHIFT +#define TIM_32B_CCER_CC3P_MASK TIM2_CCER_CC3P_MASK +#define TIM_32B_CCER_CC3P(x) TIM2_CCER_CC3P(x) + +#define TIM_32B_CCER_CC3E_SHIFT TIM2_CCER_CC3E_SHIFT +#define TIM_32B_CCER_CC3E_MASK TIM2_CCER_CC3E_MASK +#define TIM_32B_CCER_CC3E(x) TIM2_CCER_CC3E(x) + +#define TIM_32B_CCER_CC2NP_SHIFT TIM2_CCER_CC2NP_SHIFT +#define TIM_32B_CCER_CC2NP_MASK TIM2_CCER_CC2NP_MASK +#define TIM_32B_CCER_CC2NP(x) TIM2_CCER_CC2NP(x) + +#define TIM_32B_CCER_CC2P_SHIFT TIM2_CCER_CC2P_SHIFT +#define TIM_32B_CCER_CC2P_MASK TIM2_CCER_CC2P_MASK +#define TIM_32B_CCER_CC2P(x) TIM2_CCER_CC2P(x) + +#define TIM_32B_CCER_CC2E_SHIFT TIM2_CCER_CC2E_SHIFT +#define TIM_32B_CCER_CC2E_MASK TIM2_CCER_CC2E_MASK +#define TIM_32B_CCER_CC2E(x) TIM2_CCER_CC2E(x) + +#define TIM_32B_CCER_CC1NP_SHIFT TIM2_CCER_CC1NP_SHIFT +#define TIM_32B_CCER_CC1NP_MASK TIM2_CCER_CC1NP_MASK +#define TIM_32B_CCER_CC1NP(x) TIM2_CCER_CC1NP(x) + +#define TIM_32B_CCER_CC1P_SHIFT TIM2_CCER_CC1P_SHIFT +#define TIM_32B_CCER_CC1P_MASK TIM2_CCER_CC1P_MASK +#define TIM_32B_CCER_CC1P(x) TIM2_CCER_CC1P(x) + +#define TIM_32B_CCER_CC1E_SHIFT TIM2_CCER_CC1E_SHIFT +#define TIM_32B_CCER_CC1E_MASK TIM2_CCER_CC1E_MASK +#define TIM_32B_CCER_CC1E(x) TIM2_CCER_CC1E(x) + +/*! + * @brief TIM_32B_CNT Register Bit Definition + */ + +#define TIM_32B_CNT_CNT_SHIFT TIM2_CNT_CNT_SHIFT +#define TIM_32B_CNT_CNT_MASK TIM2_CNT_CNT_MASK +#define TIM_32B_CNT_CNT(x) TIM2_CNT_CNT(x) + +/*! + * @brief TIM_32B_PSC Register Bit Definition + */ + +#define TIM_32B_PSC_PSC_SHIFT TIM2_PSC_PSC_SHIFT +#define TIM_32B_PSC_PSC_MASK TIM2_PSC_PSC_MASK +#define TIM_32B_PSC_PSC(x) TIM2_PSC_PSC(x) + +/*! + * @brief TIM_32B_ARR Register Bit Definition + */ + +#define TIM_32B_ARR_ARR_SHIFT TIM2_ARR_ARR_SHIFT +#define TIM_32B_ARR_ARR_MASK TIM2_ARR_ARR_MASK +#define TIM_32B_ARR_ARR(x) TIM2_ARR_ARR(x) + +/*! + * @brief TIM_32B_CCR1 Register Bit Definition + */ + +#define TIM_32B_CCR1_CCR1_SHIFT TIM2_CCR1_CCR1_SHIFT +#define TIM_32B_CCR1_CCR1_MASK TIM2_CCR1_CCR1_MASK +#define TIM_32B_CCR1_CCR1(x) TIM2_CCR1_CCR1(x) + +/*! + * @brief TIM_32B_CCR2 Register Bit Definition + */ + +#define TIM_32B_CCR2_CCR2_SHIFT TIM2_CCR2_CCR2_SHIFT +#define TIM_32B_CCR2_CCR2_MASK TIM2_CCR2_CCR2_MASK +#define TIM_32B_CCR2_CCR2(x) TIM2_CCR2_CCR2(x) + +/*! + * @brief TIM_32B_CCR3 Register Bit Definition + */ + +#define TIM_32B_CCR3_CCR3_SHIFT TIM2_CCR3_CCR3_SHIFT +#define TIM_32B_CCR3_CCR3_MASK TIM2_CCR3_CCR3_MASK +#define TIM_32B_CCR3_CCR3(x) TIM2_CCR3_CCR3(x) + +/*! + * @brief TIM_32B_CCR4 Register Bit Definition + */ + +#define TIM_32B_CCR4_CCR4_SHIFT TIM2_CCR4_CCR4_SHIFT +#define TIM_32B_CCR4_CCR4_MASK TIM2_CCR4_CCR4_MASK +#define TIM_32B_CCR4_CCR4(x) TIM2_CCR4_CCR4(x) + +/*! + * @brief TIM_32B_DCR Register Bit Definition + */ + +#define TIM_32B_DCR_DBL_SHIFT TIM2_DCR_DBL_SHIFT +#define TIM_32B_DCR_DBL_MASK TIM2_DCR_DBL_MASK +#define TIM_32B_DCR_DBL(x) TIM2_DCR_DBL(x) + +#define TIM_32B_DCR_DBA_SHIFT TIM2_DCR_DBA_SHIFT +#define TIM_32B_DCR_DBA_MASK TIM2_DCR_DBA_MASK +#define TIM_32B_DCR_DBA(x) TIM2_DCR_DBA(x) + +/*! + * @brief TIM_32B_DMAR Register Bit Definition + */ + +#define TIM_32B_DMAR_DMAB_SHIFT TIM2_DMAR_DMAB_SHIFT +#define TIM_32B_DMAR_DMAB_MASK TIM2_DMAR_DMAB_MASK +#define TIM_32B_DMAR_DMAB(x) TIM2_DMAR_DMAB(x) + +/*! + * @brief TIM_32B_OR Register Bit Definition + */ + +#define TIM_32B_OR_TI4RMP_SHIFT TIM2_OR_TI4RMP_SHIFT +#define TIM_32B_OR_TI4RMP_MASK TIM2_OR_TI4RMP_MASK +#define TIM_32B_OR_TI4RMP(x) TIM2_OR_TI4RMP(x) + +#define TIM_32B_OR_ETRRMP_SHIFT TIM2_OR_ETRRMP_SHIFT +#define TIM_32B_OR_ETRRMP_MASK TIM2_OR_ETRRMP_MASK +#define TIM_32B_OR_ETRRMP(x) TIM2_OR_ETRRMP(x) + +/*! + * @} + */ /* end of group TIM_32B_Register_Masks */ + +/******************************************************************************* + * TIM6 Type + ******************************************************************************/ + +/*! + * @addtogroup TIM_BASIC_Register_Masks Register Masks + * @{ + */ + +/*! + * @brief TIM_BASIC_CR1 Register Bit Definition + */ + +#define TIM_BASIC_CR1_APRE_SHIFT TIM6_CR1_APRE_SHIFT +#define TIM_BASIC_CR1_APRE_MASK TIM6_CR1_APRE_MASK +#define TIM_BASIC_CR1_APRE(x) TIM6_CR1_APRE(x) + +#define TIM_BASIC_CR1_OPM_SHIFT TIM6_CR1_OPM_SHIFT +#define TIM_BASIC_CR1_OPM_MASK TIM6_CR1_OPM_MASK +#define TIM_BASIC_CR1_OPM(x) TIM6_CR1_OPM(x) + +#define TIM_BASIC_CR1_URS_SHIFT TIM6_CR1_URS_SHIFT +#define TIM_BASIC_CR1_URS_MASK TIM6_CR1_URS_MASK +#define TIM_BASIC_CR1_URS(x) TIM6_CR1_URS(x) + +#define TIM_BASIC_CR1_UDIS_SHIFT TIM6_CR1_UDIS_SHIFT +#define TIM_BASIC_CR1_UDIS_MASK TIM6_CR1_UDIS_MASK +#define TIM_BASIC_CR1_UDIS(x) TIM6_CR1_UDIS(x) + +#define TIM_BASIC_CR1_CEN_SHIFT TIM6_CR1_CEN_SHIFT +#define TIM_BASIC_CR1_CEN_MASK TIM6_CR1_CEN_MASK +#define TIM_BASIC_CR1_CEN(x) TIM6_CR1_CEN(x) + +/*! + * @brief TIM_BASIC_DIER Register Bit Definition + */ + +#define TIM_BASIC_DIER_UDE_SHIFT TIM6_DIER_UDE_SHIFT +#define TIM_BASIC_DIER_UDE_MASK TIM6_DIER_UDE_MASK +#define TIM_BASIC_DIER_UDE(x) TIM6_DIER_UDE(x) + +#define TIM_BASIC_DIER_UIE_SHIFT TIM6_DIER_UIE_SHIFT +#define TIM_BASIC_DIER_UIE_MASK TIM6_DIER_UIE_MASK +#define TIM_BASIC_DIER_UIE(x) TIM6_DIER_UIE(x) + +/*! + * @brief TIM_BASIC_SR Register Bit Definition + */ + +#define TIM_BASIC_SR_UIF_SHIFT TIM6_SR_UIF_SHIFT +#define TIM_BASIC_SR_UIF_MASK TIM6_SR_UIF_MASK +#define TIM_BASIC_SR_UIF(x) TIM6_SR_UIF(x) + +/*! + * @brief TIM_BASIC_EGR Register Bit Definition + */ + +#define TIM_BASIC_EGR_UG_SHIFT TIM6_EGR_UG_SHIFT +#define TIM_BASIC_EGR_UG_MASK TIM6_EGR_UG_MASK +#define TIM_BASIC_EGR_UG(x) TIM6_EGR_UG(x) + +/*! + * @brief TIM_BASIC_CNT Register Bit Definition + */ + +#define TIM_BASIC_CNT_CNT_SHIFT TIM6_CNT_CNT_SHIFT +#define TIM_BASIC_CNT_CNT_MASK TIM6_CNT_CNT_MASK +#define TIM_BASIC_CNT_CNT(x) TIM6_CNT_CNT(x) + +/*! + * @brief TIM_BASIC_PSC Register Bit Definition + */ + +#define TIM_BASIC_PSC_PSC_SHIFT TIM6_PSC_PSC_SHIFT +#define TIM_BASIC_PSC_PSC_MASK TIM6_PSC_PSC_MASK +#define TIM_BASIC_PSC_PSC(x) TIM6_PSC_PSC(x) + +/*! + * @brief TIM_BASIC_ARR Register Bit Definition + */ + +#define TIM_BASIC_ARR_ARR_SHIFT TIM6_ARR_ARR_SHIFT +#define TIM_BASIC_ARR_ARR_MASK TIM6_ARR_ARR_MASK +#define TIM_BASIC_ARR_ARR(x) TIM6_ARR_ARR(x) + +/*! + * @} + */ /* end of group TIM_BASIC_Register_Masks */ + + #endif /* __MM32F3277G_FEATURES_H__ */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/system_mm32f3277g.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/system_mm32f3277g.h new file mode 100644 index 0000000000..a257141fb7 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Include/system_mm32f3277g.h @@ -0,0 +1,14 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#ifndef __SYSTEM_MM32F327X_H__ +#define __SYSTEM_MM32F327X_H__ + +void SystemInit(void); + +#endif /* __SYSTEM_MM32F327X_H__ */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/linker/mm32f3277g_flash.sct b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/linker/mm32f3277g_flash.sct new file mode 100644 index 0000000000..4cbfaf8ce2 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/linker/mm32f3277g_flash.sct @@ -0,0 +1,16 @@ +; ************************************************************* +; *** Scatter-Loading Description File generated by uVision *** +; ************************************************************* + +LR_IROM1 0x08000000 0x00080000 { ; load region size_region + ER_IROM1 0x08000000 0x00080000 { ; load address = execution address + *.o (RESET, +First) + *(InRoot$$Sections) + .ANY (+RO) + .ANY (+XO) + } + RW_IRAM1 0x20000000 0x00020000 { ; RW data + .ANY (+RW +ZI) + } +} + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/startup_mm32f3270.s b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/startup_mm32f3270.s new file mode 100644 index 0000000000..03878485a9 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/startup_mm32f3270.s @@ -0,0 +1,375 @@ +; //////////////////////////////////////////////////////////////////////////////// +; /// @file startup_mm32f327x_keil.s +; /// @author AE TEAM +; /// @brief THIS FILE PROVIDES ALL THE Device Startup File of MM32 Cortex-M +; /// Core Device for ARM KEIL toolchain. +; //////////////////////////////////////////////////////////////////////////////// +; /// @attention +; /// +; /// THE EXISTING FIRMWARE IS ONLY FOR REFERENCE, WHICH IS DESIGNED TO PROVIDE +; /// CUSTOMERS WITH CODING INFORMATION ABOUT THEIR PRODUCTS SO THEY CAN SAVE +; /// TIME. THEREFORE, MINDMOTION SHALL NOT BE LIABLE FOR ANY DIRECT, INDIRECT OR +; /// CONSEQUENTIAL DAMAGES ABOUT ANY CLAIMS ARISING OUT OF THE CONTENT OF SUCH +; /// HARDWARE AND/OR THE USE OF THE CODING INFORMATION CONTAINED HEREIN IN +; /// CONNECTION WITH PRODUCTS MADE BY CUSTOMERS. +; /// +; ///

© COPYRIGHT MINDMOTION

+; ////////////////////////////////////////////////////////////////////////////// +; +; Amount of memory (in bytes) allocated for Stack +; Tailor this value to your application needs +; Stack Configuration +; Stack Size (in Bytes) <0x0-0xFFFFFFFF:8> +; + +Stack_Size EQU 0x00000400 + + AREA STACK, NOINIT, READWRITE, ALIGN=3 +Stack_Mem SPACE Stack_Size +__initial_sp + +; Heap Configuration +; Heap Size (in Bytes) <0x0-0xFFFFFFFF:8> +; +Heap_Size EQU 0x00000200 + + AREA HEAP, NOINIT, READWRITE, ALIGN=3 +__heap_base +Heap_Mem SPACE Heap_Size +__heap_limit + + PRESERVE8 + THUMB + +; Vector Table Mapped to Address 0 at Reset + AREA RESET, DATA, READONLY + EXPORT __Vectors + EXPORT __Vectors_End + EXPORT __Vectors_Size + +__Vectors DCD __initial_sp ; Top of Stack + DCD Reset_Handler ; Reset Handler + DCD NMI_Handler ; -14 NMI Handler + DCD HardFault_Handler ; -13 Hard Fault Handler + DCD MemManage_Handler ; -12 MPU Fault Handler + DCD BusFault_Handler ; -11 Bus Fault Handler + DCD UsageFault_Handler ; -10 Usage Fault Handler +__vector_table_0x1c + DCD 0 ; -9 Reserved + DCD 0 ; -8 Reserved + DCD 0 ; -7 Reserved + DCD 0 ; -6 Reserved + DCD SVC_Handler ; -5 SVCall Handler + DCD DebugMon_Handler ; -4 Debug Monitor Handler + DCD 0 ; -3 Reserved + DCD PendSV_Handler ; -2 PendSV Handler + DCD SysTick_Handler ; -1 SysTick Handler ; External Interrupts + DCD WWDG_IRQHandler ; 0 Window Watchdog + DCD PVD_IRQHandler ; 1 PVD through EXTI Line detect + DCD TAMPER_IRQHandler ; 2 Tamper + DCD RTC_IRQHandler ; 3 RTC + DCD FLASH_IRQHandler ; 4 Flash + DCD RCC_CRS_IRQHandler ; 5 RCC + DCD EXTI0_IRQHandler ; 6 EXTI Line 0 + DCD EXTI1_IRQHandler ; 7 EXTI Line 1 + DCD EXTI2_IRQHandler ; 8 EXTI Line 2 + DCD EXTI3_IRQHandler ; 9 EXTI Line 3 + DCD EXTI4_IRQHandler ; 10 EXTI Line 4 + DCD DMA1_Channel1_IRQHandler ; 11 DMA1 Channel 1 + DCD DMA1_Channel2_IRQHandler ; 12 DMA1 Channel 2 + DCD DMA1_Channel3_IRQHandler ; 13 DMA1 Channel 3 + DCD DMA1_Channel4_IRQHandler ; 14 DMA1 Channel 4 + DCD DMA1_Channel5_IRQHandler ; 15 DMA1 Channel 5 + DCD DMA1_Channel6_IRQHandler ; 16 DMA1 Channel 6 + DCD DMA1_Channel7_IRQHandler ; 17 DMA1 Channel 7 + DCD ADC1_2_IRQHandler ; 18 ADC1 and ADC2 + DCD FlashCache_IRQHandler ; 19 FlashCache outage + DCD 0 ; 20 Reserved + DCD CAN1_RX_IRQHandler ; 21 CAN1_RX + DCD 0 ; 22 Reserved + DCD EXTI9_5_IRQHandler ; 23 EXTI Line 9..5 + DCD TIM1_BRK_IRQHandler ; 24 TIM1 Break + DCD TIM1_UP_IRQHandler ; 25 TIM1 Update + DCD TIM1_TRG_COM_IRQHandler ; 26 TIM1 Trigger and Commutation + DCD TIM1_CC_IRQHandler ; 27 TIM1 Capture Compare + DCD TIM2_IRQHandler ; 28 TIM2 + DCD TIM3_IRQHandler ; 29 TIM3 + DCD TIM4_IRQHandler ; 30 TIM4 + DCD I2C1_IRQHandler ; 31 I2C1 Event + DCD 0 ; 32 Reserved + DCD I2C2_IRQHandler ; 33 I2C2 Event + DCD 0 ; 34 Reserved + DCD SPI1_IRQHandler ; 35 SPI1 + DCD SPI2_IRQHandler ; 36 SPI2 + DCD UART1_IRQHandler ; 37 UART1 + DCD UART2_IRQHandler ; 38 UART2 + DCD UART3_IRQHandler ; 39 UART3 + DCD EXTI15_10_IRQHandler ; 40 EXTI Line 15..10 + DCD RTCAlarm_IRQHandler ; 41 RTC Alarm through EXTI Line 17 + DCD OTG_FS_WKUP_IRQHandler ; 42 USB OTG FS Wakeup through EXTI line + DCD TIM8_BRK_IRQHandler ; 43 TIM8 Break + DCD TIM8_UP_IRQHandler ; 44 TIM8 Update + DCD TIM8_TRG_COM_IRQHandler ; 45 TIM8 Trigger and Commutation + DCD TIM8_CC_IRQHandler ; 46 TIM8 Capture Compare + DCD ADC3_IRQHandler ; 47 ADC3 + DCD 0 ; 48 Reserved + DCD SDIO_IRQHandler ; 49 SDIO + DCD TIM5_IRQHandler ; 50 TIM5 + DCD SPI3_IRQHandler ; 51 SPI3 + DCD UART4_IRQHandler ; 52 UART4 + DCD UART5_IRQHandler ; 53 UART5 + DCD TIM6_IRQHandler ; 54 TIM6 + DCD TIM7_IRQHandler ; 55 TIM7 + DCD DMA2_Channel1_IRQHandler ; 56 DMA2 Channel 1 + DCD DMA2_Channel2_IRQHandler ; 57 DMA2 Channel 2 + DCD DMA2_Channel3_IRQHandler ; 58 DMA2 Channel 3 + DCD DMA2_Channel4_IRQHandler ; 59 DMA2 Channel 4 + DCD DMA2_Channel5_IRQHandler ; 60 DMA2 Channel 5 + DCD ETH_IRQHandler ; 61 Ethernet + DCD 0 ; 62 Reserved + DCD 0 ; 63 Reserved + DCD COMP1_2_IRQHandler ; 64 COMP1,COMP2 + DCD 0 ; 65 Reserved + DCD 0 ; 66 Reserved + DCD OTG_FS_IRQHandler ; 67 USB OTG_FullSpeed + DCD 0 ; 68 Reserved + DCD 0 ; 69 Reserved + DCD 0 ; 70 Reserved + DCD UART6_IRQHandler ; 71 UART6 + DCD 0 ; 72 Reserved + DCD 0 ; 73 Reserved + DCD 0 ; 74 Reserved + DCD 0 ; 75 Reserved + DCD 0 ; 76 Reserved + DCD 0 ; 77 Reserved + DCD 0 ; 78 Reserved + DCD 0 ; 79 Reserved + DCD 0 ; 80 Reserved + DCD 0 ; 81 Reserved + DCD UART7_IRQHandler ; 82 UART7 + DCD UART8_IRQHandler ; 83 UART8 + +__Vectors_End + +__Vectors_Size EQU __Vectors_End - __Vectors + + AREA |.text|, CODE, READONLY + +; Reset handler +Reset_Handler PROC + EXPORT Reset_Handler [WEAK] + IMPORT __main + IMPORT SystemInit + LDR R0, =SystemInit + BLX R0 + LDR R0, =__main + BX R0 + ENDP + +; Dummy Exception Handlers (infinite loops which can be modified) + +NMI_Handler PROC + EXPORT NMI_Handler [WEAK] + B . + ENDP +HardFault_Handler\ + PROC + EXPORT HardFault_Handler [WEAK] + B . + ENDP +MemManage_Handler\ + PROC + EXPORT MemManage_Handler [WEAK] + B . + ENDP +BusFault_Handler\ + PROC + EXPORT BusFault_Handler [WEAK] + B . + ENDP +UsageFault_Handler\ + PROC + EXPORT UsageFault_Handler [WEAK] + B . + ENDP +SVC_Handler PROC + EXPORT SVC_Handler [WEAK] + B . + ENDP +DebugMon_Handler\ + PROC + EXPORT DebugMon_Handler [WEAK] + B . + ENDP +PendSV_Handler PROC + EXPORT PendSV_Handler [WEAK] + B . + ENDP +SysTick_Handler PROC + EXPORT SysTick_Handler [WEAK] + B . + ENDP + +Default_Handler PROC + + EXPORT WWDG_IRQHandler [WEAK] + EXPORT PVD_IRQHandler [WEAK] + EXPORT TAMPER_IRQHandler [WEAK] + EXPORT RTC_IRQHandler [WEAK] + EXPORT FLASH_IRQHandler [WEAK] + EXPORT RCC_CRS_IRQHandler [WEAK] + EXPORT EXTI0_IRQHandler [WEAK] + EXPORT EXTI1_IRQHandler [WEAK] + EXPORT EXTI2_IRQHandler [WEAK] + EXPORT EXTI3_IRQHandler [WEAK] + EXPORT EXTI4_IRQHandler [WEAK] + EXPORT DMA1_Channel1_IRQHandler [WEAK] + EXPORT DMA1_Channel2_IRQHandler [WEAK] + EXPORT DMA1_Channel3_IRQHandler [WEAK] + EXPORT DMA1_Channel4_IRQHandler [WEAK] + EXPORT DMA1_Channel5_IRQHandler [WEAK] + EXPORT DMA1_Channel6_IRQHandler [WEAK] + EXPORT DMA1_Channel7_IRQHandler [WEAK] + EXPORT ADC1_2_IRQHandler [WEAK] + EXPORT FlashCache_IRQHandler [WEAK] + EXPORT CAN1_RX_IRQHandler [WEAK] + EXPORT EXTI9_5_IRQHandler [WEAK] + EXPORT TIM1_BRK_IRQHandler [WEAK] + EXPORT TIM1_UP_IRQHandler [WEAK] + EXPORT TIM1_TRG_COM_IRQHandler [WEAK] + EXPORT TIM1_CC_IRQHandler [WEAK] + EXPORT TIM2_IRQHandler [WEAK] + EXPORT TIM3_IRQHandler [WEAK] + EXPORT TIM4_IRQHandler [WEAK] + EXPORT I2C1_IRQHandler [WEAK] + EXPORT I2C2_IRQHandler [WEAK] + EXPORT SPI1_IRQHandler [WEAK] + EXPORT SPI2_IRQHandler [WEAK] + EXPORT UART1_IRQHandler [WEAK] + EXPORT UART2_IRQHandler [WEAK] + EXPORT UART3_IRQHandler [WEAK] + EXPORT EXTI15_10_IRQHandler [WEAK] + EXPORT RTCAlarm_IRQHandler [WEAK] + EXPORT OTG_FS_WKUP_IRQHandler [WEAK] + EXPORT TIM8_BRK_IRQHandler [WEAK] + EXPORT TIM8_UP_IRQHandler [WEAK] + EXPORT TIM8_TRG_COM_IRQHandler [WEAK] + EXPORT TIM8_CC_IRQHandler [WEAK] + EXPORT ADC3_IRQHandler [WEAK] + EXPORT SDIO_IRQHandler [WEAK] + EXPORT TIM5_IRQHandler [WEAK] + EXPORT SPI3_IRQHandler [WEAK] + EXPORT UART4_IRQHandler [WEAK] + EXPORT UART5_IRQHandler [WEAK] + EXPORT TIM6_IRQHandler [WEAK] + EXPORT TIM7_IRQHandler [WEAK] + EXPORT DMA2_Channel1_IRQHandler [WEAK] + EXPORT DMA2_Channel2_IRQHandler [WEAK] + EXPORT DMA2_Channel3_IRQHandler [WEAK] + EXPORT DMA2_Channel4_IRQHandler [WEAK] + EXPORT DMA2_Channel5_IRQHandler [WEAK] + EXPORT ETH_IRQHandler [WEAK] + EXPORT COMP1_2_IRQHandler [WEAK] + EXPORT OTG_FS_IRQHandler [WEAK] + EXPORT UART6_IRQHandler [WEAK] + EXPORT UART7_IRQHandler [WEAK] + EXPORT UART8_IRQHandler [WEAK] + +WWDG_IRQHandler +PVD_IRQHandler +TAMPER_IRQHandler +RTC_IRQHandler +FLASH_IRQHandler +RCC_CRS_IRQHandler +EXTI0_IRQHandler +EXTI1_IRQHandler +EXTI2_IRQHandler +EXTI3_IRQHandler +EXTI4_IRQHandler +DMA1_Channel1_IRQHandler +DMA1_Channel2_IRQHandler +DMA1_Channel3_IRQHandler +DMA1_Channel4_IRQHandler +DMA1_Channel5_IRQHandler +DMA1_Channel6_IRQHandler +DMA1_Channel7_IRQHandler +ADC1_2_IRQHandler +FlashCache_IRQHandler +CAN1_RX_IRQHandler +EXTI9_5_IRQHandler +TIM1_BRK_IRQHandler +TIM1_UP_IRQHandler +TIM1_TRG_COM_IRQHandler +TIM1_CC_IRQHandler +TIM2_IRQHandler +TIM3_IRQHandler +TIM4_IRQHandler +I2C1_IRQHandler +I2C2_IRQHandler +SPI1_IRQHandler +SPI2_IRQHandler +UART1_IRQHandler +UART2_IRQHandler +UART3_IRQHandler +EXTI15_10_IRQHandler +RTCAlarm_IRQHandler +OTG_FS_WKUP_IRQHandler +TIM8_BRK_IRQHandler +TIM8_UP_IRQHandler +TIM8_TRG_COM_IRQHandler +TIM8_CC_IRQHandler +ADC3_IRQHandler +SDIO_IRQHandler +TIM5_IRQHandler +SPI3_IRQHandler +UART4_IRQHandler +UART5_IRQHandler +TIM6_IRQHandler +TIM7_IRQHandler +DMA2_Channel1_IRQHandler +DMA2_Channel2_IRQHandler +DMA2_Channel3_IRQHandler +DMA2_Channel4_IRQHandler +DMA2_Channel5_IRQHandler +ETH_IRQHandler +COMP1_2_IRQHandler +OTG_FS_IRQHandler +UART6_IRQHandler +UART7_IRQHandler +UART8_IRQHandler + + + B . + + ENDP + + ALIGN + +;******************************************************************************* +; User Stack and Heap initialization +;******************************************************************************* + IF :DEF:__MICROLIB + + EXPORT __initial_sp + EXPORT __heap_base + EXPORT __heap_limit + + ELSE + + IMPORT __use_two_region_memory + EXPORT __user_initial_stackheap + +__user_initial_stackheap + + LDR R0, = Heap_Mem + LDR R1, = (Stack_Mem + Stack_Size) + LDR R2, = (Heap_Mem + Heap_Size) + LDR R3, = Stack_Mem + BX LR + + ALIGN + + ENDIF + + END + \ No newline at end of file diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/linker/mm32f3277g_flash.ld b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/linker/mm32f3277g_flash.ld new file mode 100644 index 0000000000..1fc009995a --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/linker/mm32f3277g_flash.ld @@ -0,0 +1,208 @@ +/* +** ################################################################### +** Processors: MM32F3277G +** +** Compiler: GNU C Compiler +** Build: b211202 +** +** Abstract: +** Linker file for the GNU C Compiler +** +** Copyright 2021 MindMotion Microelectronics Co., Ltd. +** +** SPDX-License-Identifier: BSD-3-Clause +** +** +** ################################################################### +*/ + +/* Entry Point */ +ENTRY(Reset_Handler) + +HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400; +STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400; + +/* Specify the memory areas */ +MEMORY +{ + m_interrupts (RX) : ORIGIN = 0x08000000, LENGTH = 0x00000400 + m_text (RX) : ORIGIN = 0x08000400, LENGTH = 0x0007FC00 /* 512KB. */ + m_data (RW) : ORIGIN = 0x20000000, LENGTH = 0x00020000 /* 128KB. */ +} + +/* Define output sections */ +SECTIONS +{ + /* The startup code goes first into internal flash */ + .interrupts : + { + . = ALIGN(4); + KEEP(*(.isr_vector)) /* Startup code */ + . = ALIGN(4); + } > m_interrupts + + + /* The program code and other data goes into internal flash */ + .text : + { + . = ALIGN(4); + *(.text) /* .text sections (code) */ + *(.text*) /* .text* sections (code) */ + *(.rodata) /* .rodata sections (constants, strings, etc.) */ + *(.rodata*) /* .rodata* sections (constants, strings, etc.) */ + *(.glue_7) /* glue arm to thumb code */ + *(.glue_7t) /* glue thumb to arm code */ + *(.eh_frame) + KEEP (*(.init)) + KEEP (*(.fini)) + . = ALIGN(4); + } > m_text + + .ARM.extab : + { + *(.ARM.extab* .gnu.linkonce.armextab.*) + } > m_text + + .ARM : + { + __exidx_start = .; + *(.ARM.exidx*) + __exidx_end = .; + } > m_text + + .ctors : + { + __CTOR_LIST__ = .; + /* gcc uses crtbegin.o to find the start of + the constructors, so we make sure it is + first. Because this is a wildcard, it + doesn't matter if the user does not + actually link against crtbegin.o; the + linker won't look for a file to match a + wildcard. The wildcard also means that it + doesn't matter which directory crtbegin.o + is in. */ + KEEP (*crtbegin.o(.ctors)) + KEEP (*crtbegin?.o(.ctors)) + /* We don't want to include the .ctor section from + from the crtend.o file until after the sorted ctors. + The .ctor section from the crtend file contains the + end of ctors marker and it must be last */ + KEEP (*(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)) + KEEP (*(SORT(.ctors.*))) + KEEP (*(.ctors)) + __CTOR_END__ = .; + } > m_text + + .dtors : + { + __DTOR_LIST__ = .; + KEEP (*crtbegin.o(.dtors)) + KEEP (*crtbegin?.o(.dtors)) + KEEP (*(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)) + KEEP (*(SORT(.dtors.*))) + KEEP (*(.dtors)) + __DTOR_END__ = .; + } > m_text + + .preinit_array : + { + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP (*(.preinit_array*)) + PROVIDE_HIDDEN (__preinit_array_end = .); + } > m_text + + .init_array : + { + PROVIDE_HIDDEN (__init_array_start = .); + KEEP (*(SORT(.init_array.*))) + KEEP (*(.init_array*)) + PROVIDE_HIDDEN (__init_array_end = .); + } > m_text + + .fini_array : + { + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP (*(SORT(.fini_array.*))) + KEEP (*(.fini_array*)) + PROVIDE_HIDDEN (__fini_array_end = .); + } > m_text + + __etext = .; /* define a global symbol at end of code */ + __DATA_ROM = .; /* Symbol is used by startup for data initialization */ + + .data : AT(__DATA_ROM) + { + . = ALIGN(4); + __DATA_RAM = .; + __data_start__ = .; /* create a global symbol at data start */ + *(.data) /* .data sections */ + *(.data*) /* .data* sections */ + KEEP(*(.jcr*)) + . = ALIGN(4); + __data_end__ = .; /* define a global symbol at data end */ + } > m_data + + __NDATA_ROM = __DATA_ROM + (__data_end__ - __data_start__); + .ncache.init : AT(__NDATA_ROM) + { + __noncachedata_start__ = .; /* create a global symbol at ncache data start */ + *(NonCacheable.init) + . = ALIGN(4); + __noncachedata_init_end__ = .; /* create a global symbol at initialized ncache data end */ + } > m_data + + . = __noncachedata_init_end__; + .ncache : + { + *(NonCacheable) + . = ALIGN(4); + __noncachedata_end__ = .; /* define a global symbol at ncache data end */ + } > m_data + + __DATA_END = __NDATA_ROM + (__noncachedata_init_end__ - __noncachedata_start__); + text_end = ORIGIN(m_text) + LENGTH(m_text); + ASSERT(__DATA_END <= text_end, "region m_text overflowed with text and data") + + /* Uninitialized data section */ + .bss : + { + /* This is used by the startup in order to initialize the .bss section */ + . = ALIGN(4); + __START_BSS = .; + __bss_start__ = .; + *(.bss) + *(.bss*) + *(COMMON) + . = ALIGN(4); + __bss_end__ = .; + __END_BSS = .; + } > m_data + + .heap : + { + . = ALIGN(8); + __end__ = .; + PROVIDE(end = .); + __HeapBase = .; + . += HEAP_SIZE; + __HeapLimit = .; + __heap_limit = .; /* Add for _sbrk */ + } > m_data + + .stack : + { + . = ALIGN(8); + . += STACK_SIZE; + } > m_data + + /* Initializes stack on the end of block */ + __StackTop = ORIGIN(m_data) + LENGTH(m_data); + __StackLimit = __StackTop - STACK_SIZE; + PROVIDE(__stack = __StackTop); + + .ARM.attributes 0 : { *(.ARM.attributes) } + + ASSERT(__StackLimit >= __HeapLimit, "region m_data_2 overflowed with stack and heap") +} + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/startup_mm32f3270.s b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/startup_mm32f3270.s new file mode 100644 index 0000000000..140ac225bc --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/startup_mm32f3270.s @@ -0,0 +1,399 @@ +/* ------------------------------------------------------------------------- */ +/* @file: startup_MM32F3270.s */ +/* @purpose: CMSIS Cortex-M3 Core Device Startup File */ +/* */ +/* @version: 1.0 */ +/* @date: 2021-7-21 */ +/* @build: b210721 */ +/* ------------------------------------------------------------------------- */ +/* */ +/* Copyright 2021 MindMotion */ +/* All rights reserved. */ +/* */ +/* SPDX-License-Identifier: BSD-3-Clause */ +/*****************************************************************************/ +/* Version: GCC for ARM Embedded Processors */ +/*****************************************************************************/ + .syntax unified + .arch armv7-m + + .section .isr_vector, "a" + .align 2 + .globl __isr_vector +__isr_vector: + .long __StackTop /* Top of Stack */ + .long Reset_Handler /* Reset Handler */ + .long NMI_Handler /* NMI Handler*/ + .long HardFault_Handler /* Hard Fault Handler*/ + .long MemManage_Handler /* MPU Fault Handler*/ + .long BusFault_Handler /* Bus Fault Handler*/ + .long UsageFault_Handler /* Usage Fault Handler*/ + .long 0 /* Reserved*/ + .long 0 /* Reserved*/ + .long 0 /* Reserved*/ + .long 0 /* Reserved*/ + .long SVC_Handler /* SVCall Handler*/ + .long DebugMon_Handler /* Debug Monitor Handler*/ + .long 0 /* Reserved*/ + .long PendSV_Handler /* PendSV Handler*/ + .long SysTick_Handler /* SysTick Handler*/ + + .long WWDG_IRQHandler /* 0 Window Watchdog */ + .long PVD_IRQHandler /* 1 PVD through EXTI Line detect */ + .long TAMPER_IRQHandler /* 2 Tamper */ + .long RTC_IRQHandler /* 3 RTC */ + .long FLASH_IRQHandler /* 4 Flash */ + .long RCC_CRS_IRQHandler /* 5 RCC */ + .long EXTI0_IRQHandler /* 6 EXTI Line 0 */ + .long EXTI1_IRQHandler /* 7 EXTI Line 1 */ + .long EXTI2_IRQHandler /* 8 EXTI Line 2 */ + .long EXTI3_IRQHandler /* 9 EXTI Line 3 */ + .long EXTI4_IRQHandler /* 10 EXTI Line 4 */ + .long DMA1_Channel1_IRQHandler /* 11 DMA1 Channel 1 */ + .long DMA1_Channel2_IRQHandler /* 12 DMA1 Channel 2 */ + .long DMA1_Channel3_IRQHandler /* 13 DMA1 Channel 3 */ + .long DMA1_Channel4_IRQHandler /* 14 DMA1 Channel 4 */ + .long DMA1_Channel5_IRQHandler /* 15 DMA1 Channel 5 */ + .long DMA1_Channel6_IRQHandler /* 16 DMA1 Channel 6 */ + .long DMA1_Channel7_IRQHandler /* 17 DMA1 Channel 7 */ + .long ADC1_2_IRQHandler /* 18 ADC1 and ADC2 */ + .long FlashCache_IRQHandler /* 19 FlashCache outage */ + .long 0 /* 20 Reserved */ + .long CAN1_RX_IRQHandler /* 21 CAN1_RX */ + .long 0 /* 22 Reserved */ + .long EXTI9_5_IRQHandler /* 23 EXTI Line 9..5 */ + .long TIM1_BRK_IRQHandler /* 24 TIM1 Break */ + .long TIM1_UP_IRQHandler /* 25 TIM1 Update */ + .long TIM1_TRG_COM_IRQHandler /* 26 TIM1 Trigger and Commutation */ + .long TIM1_CC_IRQHandler /* 27 TIM1 Capture Compare */ + .long TIM2_IRQHandler /* 28 TIM2 */ + .long TIM3_IRQHandler /* 29 TIM3 */ + .long TIM4_IRQHandler /* 30 TIM4 */ + .long I2C1_IRQHandler /* 31 I2C1 Event */ + .long 0 /* 32 Reserved */ + .long I2C2_IRQHandler /* 33 I2C2 Event */ + .long 0 /* 34 Reserved */ + .long SPI1_IRQHandler /* 35 SPI1 */ + .long SPI2_IRQHandler /* 36 SPI2 */ + .long UART1_IRQHandler /* 37 UART1 */ + .long UART2_IRQHandler /* 38 UART2 */ + .long UART3_IRQHandler /* 39 UART3 */ + .long EXTI15_10_IRQHandler /* 40 EXTI Line 15..10 */ + .long RTCAlarm_IRQHandler /* 41 RTC Alarm through EXTI Line 17 */ + .long OTG_FS_WKUP_IRQHandler /* 42 USB OTG FS Wakeup through EXTI line */ + .long TIM8_BRK_IRQHandler /* 43 TIM8 Break */ + .long TIM8_UP_IRQHandler /* 44 TIM8 Update */ + .long TIM8_TRG_COM_IRQHandler /* 45 TIM8 Trigger and Commutation */ + .long TIM8_CC_IRQHandler /* 46 TIM8 Capture Compare */ + .long ADC3_IRQHandler /* 47 ADC3 */ + .long 0 /* 48 Reserved */ + .long SDIO_IRQHandler /* 49 SDIO */ + .long TIM5_IRQHandler /* 50 TIM5 */ + .long SPI3_IRQHandler /* 51 SPI3 */ + .long UART4_IRQHandler /* 52 UART4 */ + .long UART5_IRQHandler /* 53 UART5 */ + .long TIM6_IRQHandler /* 54 TIM6 */ + .long TIM7_IRQHandler /* 55 TIM7 */ + .long DMA2_Channel1_IRQHandler /* 56 DMA2 Channel 1 */ + .long DMA2_Channel2_IRQHandler /* 57 DMA2 Channel 2 */ + .long DMA2_Channel3_IRQHandler /* 58 DMA2 Channel 3 */ + .long DMA2_Channel4_IRQHandler /* 59 DMA2 Channel 4 */ + .long DMA2_Channel5_IRQHandler /* 60 DMA2 Channel 5 */ + .long ETH_IRQHandler /* 61 Ethernet */ + .long 0 /* 62 Reserved */ + .long 0 /* 63 Reserved */ + .long COMP1_2_IRQHandler /* 64 COMP1,COMP2 */ + .long 0 /* 65 Reserved */ + .long 0 /* 66 Reserved */ + .long OTG_FS_IRQHandler /* 67 USB OTG_FullSpeed */ + .long 0 /* 68 Reserved */ + .long 0 /* 69 Reserved */ + .long 0 /* 70 Reserved */ + .long UART6_IRQHandler /* 71 UART6 */ + .long 0 /* 72 Reserved */ + .long 0 /* 73 Reserved */ + .long 0 /* 74 Reserved */ + .long 0 /* 75 Reserved */ + .long 0 /* 76 Reserved */ + .long 0 /* 77 Reserved */ + .long 0 /* 78 Reserved */ + .long 0 /* 79 Reserved */ + .long 0 /* 80 Reserved */ + .long 0 /* 81 Reserved */ + .long UART7_IRQHandler /* 82 UART7 */ + .long UART8_IRQHandler /* 83 UART8 */ + + .long DefaultISR /* 254*/ + + .size __isr_vector, . - __isr_vector + + + + .text + .thumb + +/* Reset Handler */ + + .thumb_func + .align 2 + .globl Reset_Handler + .weak Reset_Handler + .type Reset_Handler, %function +Reset_Handler: + cpsid i /* Mask interrupts */ + .equ VTOR, 0xE000ED08 + ldr r0, =VTOR + ldr r1, =__isr_vector + str r1, [r0] + ldr r2, [r1] + msr msp, r2 +#ifndef __NO_SYSTEM_INIT + ldr r0,=SystemInit + blx r0 +#endif +/* Loop to copy data from read only memory to RAM. The ranges + * of copy from/to are specified by following symbols evaluated in + * linker script. + * __etext: End of code section, i.e., begin of data sections to copy from. + * __data_start__/__data_end__: RAM address range that data should be + * __noncachedata_start__/__noncachedata_end__ : none cachable region + * copied to. Both must be aligned to 4 bytes boundary. */ + + ldr r1, =__etext + ldr r2, =__data_start__ + ldr r3, =__data_end__ + +#ifdef __PERFORMANCE_IMPLEMENTATION +/* Here are two copies of loop implementations. First one favors performance + * and the second one favors code size. Default uses the second one. + * Define macro "__PERFORMANCE_IMPLEMENTATION" in project to use the first one */ + subs r3, r2 + ble .LC1 +.LC0: + subs r3, #4 + ldr r0, [r1, r3] + str r0, [r2, r3] + bgt .LC0 +.LC1: +#else /* code size implemenation */ +.LC0: + cmp r2, r3 + ittt lt + ldrlt r0, [r1], #4 + strlt r0, [r2], #4 + blt .LC0 +#endif +#ifdef __STARTUP_INITIALIZE_NONCACHEDATA + ldr r2, =__noncachedata_start__ + ldr r3, =__noncachedata_init_end__ +#ifdef __PERFORMANCE_IMPLEMENTATION +/* Here are two copies of loop implementations. First one favors performance + * and the second one favors code size. Default uses the second one. + * Define macro "__PERFORMANCE_IMPLEMENTATION" in project to use the first one */ + subs r3, r2 + ble .LC3 +.LC2: + subs r3, #4 + ldr r0, [r1, r3] + str r0, [r2, r3] + bgt .LC2 +.LC3: +#else /* code size implemenation */ +.LC2: + cmp r2, r3 + ittt lt + ldrlt r0, [r1], #4 + strlt r0, [r2], #4 + blt .LC2 +#endif +/* zero inited ncache section initialization */ + ldr r3, =__noncachedata_end__ + movs r0,0 +.LC4: + cmp r2,r3 + itt lt + strlt r0,[r2],#4 + blt .LC4 +#endif /* __STARTUP_INITIALIZE_NONCACHEDATA */ + +#ifdef __STARTUP_CLEAR_BSS +/* This part of work usually is done in C library startup code. Otherwise, + * define this macro to enable it in this startup. + * + * Loop to zero out BSS section, which uses following symbols + * in linker script: + * __bss_start__: start of BSS section. Must align to 4 + * __bss_end__: end of BSS section. Must align to 4 + */ + ldr r1, =__bss_start__ + ldr r2, =__bss_end__ + + movs r0, 0 +.LC5: + cmp r1, r2 + itt lt + strlt r0, [r1], #4 + blt .LC5 +#endif /* __STARTUP_CLEAR_BSS */ + + cpsie i /* Unmask interrupts */ +#ifndef __START +#define __START _start +#endif +#ifndef __ATOLLIC__ + ldr r0,=__START + blx r0 +#else + ldr r0,=__libc_init_array + blx r0 + ldr r0,=main + bx r0 +#endif + .pool + .size Reset_Handler, . - Reset_Handler + +# DefaultISR + .align 1 + .thumb_func + .weak DefaultISR + .type DefaultISR, %function +DefaultISR: + b DefaultISR + .size DefaultISR, . - DefaultISR + +# NMI_Handler + .align 1 + .thumb_func + .weak NMI_Handler + .type NMI_Handler, %function +NMI_Handler: + ldr r0,=NMI_Handler + bx r0 + .size NMI_Handler, . - NMI_Handler + +# HardFault_Handler + .align 1 + .thumb_func + .weak HardFault_Handler + .type HardFault_Handler, %function +HardFault_Handler: + ldr r0,=HardFault_Handler + bx r0 + .size HardFault_Handler, . - HardFault_Handler + +# MemManage_Handler +# BusFault_Handler +# UsageFault_Handler +# DebugMon_Handler + +# SVC_Handler + .align 1 + .thumb_func + .weak SVC_Handler + .type SVC_Handler, %function +SVC_Handler: + ldr r0,=SVC_Handler + bx r0 + .size SVC_Handler, . - SVC_Handler + +# PendSV_Handler + .align 1 + .thumb_func + .weak PendSV_Handler + .type PendSV_Handler, %function +PendSV_Handler: + ldr r0,=PendSV_Handler + bx r0 + .size PendSV_Handler, . - PendSV_Handler + +# SysTick_Handler + .align 1 + .thumb_func + .weak SysTick_Handler + .type SysTick_Handler, %function +SysTick_Handler: + ldr r0,=SysTick_Handler + bx r0 + .size SysTick_Handler, . - SysTick_Handler + + +/* Macro to define default handlers. Default handler + * will be weak symbol and just dead loops. They can be + * overwritten by other handlers */ + .macro def_irq_handler handler_name + .weak \handler_name + .set \handler_name, DefaultISR + .endm + +/* Exception Handlers */ + def_irq_handler MemManage_Handler + def_irq_handler BusFault_Handler + def_irq_handler UsageFault_Handler + def_irq_handler DebugMon_Handler + + + def_irq_handler WWDG_IRQHandler /* 0 Window Watchdog */ + def_irq_handler PVD_IRQHandler /* 1 PVD through EXTI Line detect */ + def_irq_handler TAMPER_IRQHandler /* 2 Tamper */ + def_irq_handler RTC_IRQHandler /* 3 RTC */ + def_irq_handler FLASH_IRQHandler /* 4 Flash */ + def_irq_handler RCC_CRS_IRQHandler /* 5 RCC */ + def_irq_handler EXTI0_IRQHandler /* 6 EXTI Line 0 */ + def_irq_handler EXTI1_IRQHandler /* 7 EXTI Line 1 */ + def_irq_handler EXTI2_IRQHandler /* 8 EXTI Line 2 */ + def_irq_handler EXTI3_IRQHandler /* 9 EXTI Line 3 */ + def_irq_handler EXTI4_IRQHandler /* 10 EXTI Line 4 */ + def_irq_handler DMA1_Channel1_IRQHandler /* 11 DMA1 Channel 1 */ + def_irq_handler DMA1_Channel2_IRQHandler /* 12 DMA1 Channel 2 */ + def_irq_handler DMA1_Channel3_IRQHandler /* 13 DMA1 Channel 3 */ + def_irq_handler DMA1_Channel4_IRQHandler /* 14 DMA1 Channel 4 */ + def_irq_handler DMA1_Channel5_IRQHandler /* 15 DMA1 Channel 5 */ + def_irq_handler DMA1_Channel6_IRQHandler /* 16 DMA1 Channel 6 */ + def_irq_handler DMA1_Channel7_IRQHandler /* 17 DMA1 Channel 7 */ + def_irq_handler ADC1_2_IRQHandler /* 18 ADC1 and ADC2 */ + def_irq_handler FlashCache_IRQHandler /* 19 FlashCache outage */ + def_irq_handler CAN1_RX_IRQHandler /* 21 CAN1_RX */ + def_irq_handler EXTI9_5_IRQHandler /* 23 EXTI Line 9..5 */ + def_irq_handler TIM1_BRK_IRQHandler /* 24 TIM1 Break */ + def_irq_handler TIM1_UP_IRQHandler /* 25 TIM1 Update */ + def_irq_handler TIM1_TRG_COM_IRQHandler /* 26 TIM1 Trigger and Commutation */ + def_irq_handler TIM1_CC_IRQHandler /* 27 TIM1 Capture Compare */ + def_irq_handler TIM2_IRQHandler /* 28 TIM2 */ + def_irq_handler TIM3_IRQHandler /* 29 TIM3 */ + def_irq_handler TIM4_IRQHandler /* 30 TIM4 */ + def_irq_handler I2C1_IRQHandler /* 31 I2C1 Event */ + def_irq_handler I2C2_IRQHandler /* 33 I2C2 Event */ + def_irq_handler SPI1_IRQHandler /* 35 SPI1 */ + def_irq_handler SPI2_IRQHandler /* 36 SPI2 */ + def_irq_handler UART1_IRQHandler /* 37 UART1 */ + def_irq_handler UART2_IRQHandler /* 38 UART2 */ + def_irq_handler UART3_IRQHandler /* 39 UART3 */ + def_irq_handler EXTI15_10_IRQHandler /* 40 EXTI Line 15..10 */ + def_irq_handler RTCAlarm_IRQHandler /* 41 RTC Alarm through EXTI Line 17 */ + def_irq_handler OTG_FS_WKUP_IRQHandler /* 42 USB OTG FS Wakeup through EXTI line */ + def_irq_handler TIM8_BRK_IRQHandler /* 43 TIM8 Break */ + def_irq_handler TIM8_UP_IRQHandler /* 44 TIM8 Update */ + def_irq_handler TIM8_TRG_COM_IRQHandler /* 45 TIM8 Trigger and Commutation */ + def_irq_handler TIM8_CC_IRQHandler /* 46 TIM8 Capture Compare */ + def_irq_handler ADC3_IRQHandler /* 47 ADC3 */ + def_irq_handler SDIO_IRQHandler /* 49 SDIO */ + def_irq_handler TIM5_IRQHandler /* 50 TIM5 */ + def_irq_handler SPI3_IRQHandler /* 51 SPI3 */ + def_irq_handler UART4_IRQHandler /* 52 UART4 */ + def_irq_handler UART5_IRQHandler /* 53 UART5 */ + def_irq_handler TIM6_IRQHandler /* 54 TIM6 */ + def_irq_handler TIM7_IRQHandler /* 55 TIM7 */ + def_irq_handler DMA2_Channel1_IRQHandler /* 56 DMA2 Channel 1 */ + def_irq_handler DMA2_Channel2_IRQHandler /* 57 DMA2 Channel 2 */ + def_irq_handler DMA2_Channel3_IRQHandler /* 58 DMA2 Channel 3 */ + def_irq_handler DMA2_Channel4_IRQHandler /* 59 DMA2 Channel 4 */ + def_irq_handler DMA2_Channel5_IRQHandler /* 60 DMA2 Channel 5 */ + def_irq_handler ETH_IRQHandler /* 61 Ethernet */ + def_irq_handler COMP1_2_IRQHandler /* 64 COMP1,COMP2 */ + def_irq_handler OTG_FS_IRQHandler /* 67 USB OTG_FullSpeed */ + def_irq_handler UART6_IRQHandler /* 71 UART6 */ + def_irq_handler UART7_IRQHandler /* 82 UART7 */ + def_irq_handler UART8_IRQHandler /* 83 UART8 */ + + + .end diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/linker/mm32f3273g.icf b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/linker/mm32f3273g.icf new file mode 100644 index 0000000000..92ab6c7b93 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/linker/mm32f3273g.icf @@ -0,0 +1,30 @@ +/*###ICF### Section handled by ICF editor, don't touch! ****/ +/*-Editor annotation file-*/ +/* IcfEditorFile="$TOOLKIT_DIR$\config\ide\IcfEditor\cortex_v1_0.xml" */ +/*-Specials-*/ +define symbol __ICFEDIT_intvec_start__ = 0x08000000; +/*-Memory Regions-*/ +define symbol __ICFEDIT_region_ROM_start__ = 0x08000000; +define symbol __ICFEDIT_region_ROM_end__ = 0x0807FFFF; +define symbol __ICFEDIT_region_RAM_start__ = 0x20000000; +define symbol __ICFEDIT_region_RAM_end__ = 0x2001FFFF; +/*-Sizes-*/ +define symbol __ICFEDIT_size_cstack__ = 0x800; +define symbol __ICFEDIT_size_heap__ = 0x800; +/**** End of ICF editor section. ###ICF###*/ + +define memory mem with size = 4G; +define region ROM_region = mem:[from __ICFEDIT_region_ROM_start__ to __ICFEDIT_region_ROM_end__]; +define region RAM_region = mem:[from __ICFEDIT_region_RAM_start__ to __ICFEDIT_region_RAM_end__]; + +define block CSTACK with alignment = 8, size = __ICFEDIT_size_cstack__ { }; +define block HEAP with alignment = 8, size = __ICFEDIT_size_heap__ { }; + +initialize by copy { readwrite }; +do not initialize { section .noinit }; + +place at address mem:__ICFEDIT_intvec_start__ { readonly section .intvec }; + +place in ROM_region { readonly }; +place in RAM_region { readwrite, + block CSTACK, block HEAP }; \ No newline at end of file diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/startup_mm32f3270.s b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/startup_mm32f3270.s new file mode 100644 index 0000000000..922605906b --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/startup_mm32f3270.s @@ -0,0 +1,306 @@ +/* ------------------------------------------------------------------------- */ +/* @file: startup_MM32F3273.s */ +/* @purpose: CMSIS Cortex-M0 Core Device Startup File */ +/* */ +/* @version: 1.0 */ +/* @date: 2021-07-21 */ +/* @build: b210721 */ +/* ------------------------------------------------------------------------- */ +/* */ +/* Copyright 2021 MindMotion */ +/* All rights reserved. */ +/* */ +/* SPDX-License-Identifier: BSD-3-Clause */ +/*****************************************************************************/ +/* Version: ICC for ARM Embedded Processors */ +/*****************************************************************************/ + + MODULE ?cstartup + + ;; Forward declaration of sections. + SECTION CSTACK:DATA:NOROOT(3) + + SECTION .intvec:CODE:NOROOT(2) + + EXTERN __iar_program_start + EXTERN SystemInit + PUBLIC __vector_table + PUBLIC __vector_table_0x1c + PUBLIC __Vectors + PUBLIC __Vectors_End + PUBLIC __Vectors_Size + + DATA +__vector_table + DCD sfe(CSTACK) ; Top of Stack + DCD Reset_Handler ; Reset Handler + DCD NMI_Handler ; -14 NMI Handler + DCD HardFault_Handler ; -13 Hard Fault Handler + DCD MemManage_Handler ; -12 MPU Fault Handler + DCD BusFault_Handler ; -11 Bus Fault Handler + DCD UsageFault_Handler ; -10 Usage Fault Handler +__vector_table_0x1c + DCD 0 ; -9 Reserved + DCD 0 ; -8 Reserved + DCD 0 ; -7 Reserved + DCD 0 ; -6 Reserved + DCD SVC_Handler ; -5 SVCall Handler + DCD DebugMon_Handler ; -4 Debug Monitor Handler + DCD 0 ; -3 Reserved + DCD PendSV_Handler ; -2 PendSV Handler + DCD SysTick_Handler ; -1 SysTick Handler ; External Interrupts + DCD WWDG_IRQHandler ; 0 Window Watchdog + DCD PVD_IRQHandler ; 1 PVD through EXTI Line detect + DCD TAMPER_IRQHandler ; 2 Tamper + DCD RTC_IRQHandler ; 3 RTC + DCD FLASH_IRQHandler ; 4 Flash + DCD RCC_CRS_IRQHandler ; 5 RCC + DCD EXTI0_IRQHandler ; 6 EXTI Line 0 + DCD EXTI1_IRQHandler ; 7 EXTI Line 1 + DCD EXTI2_IRQHandler ; 8 EXTI Line 2 + DCD EXTI3_IRQHandler ; 9 EXTI Line 3 + DCD EXTI4_IRQHandler ; 10 EXTI Line 4 + DCD DMA1_CH1_IRQHandler ; 11 DMA1 Channel 1 + DCD DMA1_CH2_IRQHandler ; 12 DMA1 Channel 2 + DCD DMA1_CH3_IRQHandler ; 13 DMA1 Channel 3 + DCD DMA1_CH4_IRQHandler ; 14 DMA1 Channel 4 + DCD DMA1_CH5_IRQHandler ; 15 DMA1 Channel 5 + DCD DMA1_CH6_IRQHandler ; 16 DMA1 Channel 6 + DCD DMA1_CH7_IRQHandler ; 17 DMA1 Channel 7 + DCD ADC1_2_IRQHandler ; 18 ADC1 and ADC2 + DCD FlashCache_IRQHandler ; 19 FlashCache outage + DCD 0 ; 20 Reserved + DCD CAN1_RX_IRQHandler ; 21 CAN1_RX + DCD 0 ; 22 Reserved + DCD EXTI9_5_IRQHandler ; 23 EXTI Line 9..5 + DCD TIM1_BRK_IRQHandler ; 24 TIM1 Break + DCD TIM1_UP_IRQHandler ; 25 TIM1 Update + DCD TIM1_TRG_COM_IRQHandler ; 26 TIM1 Trigger and Commutation + DCD TIM1_CC_IRQHandler ; 27 TIM1 Capture Compare + DCD TIM2_IRQHandler ; 28 TIM2 + DCD TIM3_IRQHandler ; 29 TIM3 + DCD TIM4_IRQHandler ; 30 TIM4 + DCD I2C1_IRQHandler ; 31 I2C1 Event + DCD 0 ; 32 Reserved + DCD I2C2_IRQHandler ; 33 I2C2 Event + DCD 0 ; 34 Reserved + DCD SPI1_IRQHandler ; 35 SPI1 + DCD SPI2_IRQHandler ; 36 SPI2 + DCD UART1_IRQHandler ; 37 UART1 + DCD UART2_IRQHandler ; 38 UART2 + DCD UART3_IRQHandler ; 39 UART3 + DCD EXTI15_10_IRQHandler ; 40 EXTI Line 15..10 + DCD RTCAlarm_IRQHandler ; 41 RTC Alarm through EXTI Line 17 + DCD OTG_FS_WKUP_IRQHandler ; 42 USB OTG FS Wakeup through EXTI line + DCD TIM8_BRK_IRQHandler ; 43 TIM8 Break + DCD TIM8_UP_IRQHandler ; 44 TIM8 Update + DCD TIM8_TRG_COM_IRQHandler ; 45 TIM8 Trigger and Commutation + DCD TIM8_CC_IRQHandler ; 46 TIM8 Capture Compare + DCD ADC3_IRQHandler ; 47 ADC3 + DCD 0 ; 48 Reserved + DCD SDIO_IRQHandler ; 49 SDIO + DCD TIM5_IRQHandler ; 50 TIM5 + DCD SPI3_IRQHandler ; 51 SPI3 + DCD UART4_IRQHandler ; 52 UART4 + DCD UART5_IRQHandler ; 53 UART5 + DCD TIM6_IRQHandler ; 54 TIM6 + DCD TIM7_IRQHandler ; 55 TIM7 + DCD DMA2_CH1_IRQHandler ; 56 DMA2 Channel 1 + DCD DMA2_CH2_IRQHandler ; 57 DMA2 Channel 2 + DCD DMA2_CH3_IRQHandler ; 58 DMA2 Channel 3 + DCD DMA2_CH4_IRQHandler ; 59 DMA2 Channel 4 + DCD DMA2_CH5_IRQHandler ; 60 DMA2 Channel 5 + DCD 0 ; 61 Reserved + DCD 0 ; 62 Reserved + DCD 0 ; 63 Reserved + DCD COMP1_2_IRQHandler ; 64 COMP1,COMP2 + DCD 0 ; 65 Reserved + DCD 0 ; 66 Reserved + DCD OTG_FS_IRQHandler ; 67 USB OTG_FullSpeed + DCD 0 ; 68 Reserved + DCD 0 ; 69 Reserved + DCD 0 ; 70 Reserved + DCD UART6_IRQHandler ; 71 UART6 + DCD 0 ; 72 Reserved + DCD 0 ; 73 Reserved + DCD 0 ; 74 Reserved + DCD 0 ; 75 Reserved + DCD 0 ; 76 Reserved + DCD 0 ; 77 Reserved + DCD 0 ; 78 Reserved + DCD 0 ; 79 Reserved + DCD 0 ; 80 Reserved + DCD 0 ; 81 Reserved + DCD UART7_IRQHandler ; 82 UART7 + DCD UART8_IRQHandler ; 83 UART8 + + +__Vectors_End + +__Vectors EQU __vector_table +__Vectors_Size EQU __Vectors_End - __Vectors + + + THUMB + +; Reset Handler + + PUBWEAK Reset_Handler + SECTION .text:CODE:REORDER:NOROOT(2) +Reset_Handler + LDR R0, =SystemInit + BLX R0 + LDR R0, =__iar_program_start + BX R0 + + + PUBWEAK NMI_Handler + PUBWEAK HardFault_Handler + PUBWEAK MemManage_Handler + PUBWEAK BusFault_Handler + PUBWEAK UsageFault_Handler + PUBWEAK SVC_Handler + PUBWEAK DebugMon_Handler + PUBWEAK PendSV_Handler + PUBWEAK SysTick_Handler + PUBWEAK WWDG_IRQHandler + PUBWEAK PVD_IRQHandler + PUBWEAK TAMPER_IRQHandler + PUBWEAK RTC_IRQHandler + PUBWEAK FLASH_IRQHandler + PUBWEAK RCC_CRS_IRQHandler + PUBWEAK EXTI0_IRQHandler + PUBWEAK EXTI1_IRQHandler + PUBWEAK EXTI2_IRQHandler + PUBWEAK EXTI3_IRQHandler + PUBWEAK EXTI4_IRQHandler + PUBWEAK DMA1_CH1_IRQHandler + PUBWEAK DMA1_CH2_IRQHandler + PUBWEAK DMA1_CH3_IRQHandler + PUBWEAK DMA1_CH4_IRQHandler + PUBWEAK DMA1_CH5_IRQHandler + PUBWEAK DMA1_CH6_IRQHandler + PUBWEAK DMA1_CH7_IRQHandler + PUBWEAK ADC1_2_IRQHandler + PUBWEAK FlashCache_IRQHandler + PUBWEAK CAN1_RX_IRQHandler + PUBWEAK EXTI9_5_IRQHandler + PUBWEAK TIM1_BRK_IRQHandler + PUBWEAK TIM1_UP_IRQHandler + PUBWEAK TIM1_TRG_COM_IRQHandler + PUBWEAK TIM1_CC_IRQHandler + PUBWEAK TIM2_IRQHandler + PUBWEAK TIM3_IRQHandler + PUBWEAK TIM4_IRQHandler + PUBWEAK I2C1_IRQHandler + PUBWEAK I2C2_IRQHandler + PUBWEAK SPI1_IRQHandler + PUBWEAK SPI2_IRQHandler + PUBWEAK UART1_IRQHandler + PUBWEAK UART2_IRQHandler + PUBWEAK UART3_IRQHandler + PUBWEAK EXTI15_10_IRQHandler + PUBWEAK RTCAlarm_IRQHandler + PUBWEAK OTG_FS_WKUP_IRQHandler + PUBWEAK TIM8_BRK_IRQHandler + PUBWEAK TIM8_UP_IRQHandler + PUBWEAK TIM8_TRG_COM_IRQHandler + PUBWEAK TIM8_CC_IRQHandler + PUBWEAK ADC3_IRQHandler + PUBWEAK SDIO_IRQHandler + PUBWEAK TIM5_IRQHandler + PUBWEAK SPI3_IRQHandler + PUBWEAK UART4_IRQHandler + PUBWEAK UART5_IRQHandler + PUBWEAK TIM6_IRQHandler + PUBWEAK TIM7_IRQHandler + PUBWEAK DMA2_CH1_IRQHandler + PUBWEAK DMA2_CH2_IRQHandler + PUBWEAK DMA2_CH3_IRQHandler + PUBWEAK DMA2_CH4_IRQHandler + PUBWEAK DMA2_CH5_IRQHandler + PUBWEAK COMP1_2_IRQHandler + PUBWEAK OTG_FS_IRQHandler + PUBWEAK UART6_IRQHandler + PUBWEAK UART7_IRQHandler + PUBWEAK UART8_IRQHandler + + + SECTION .text:CODE:REORDER:NOROOT(1) + + +NMI_Handler +HardFault_Handler +MemManage_Handler +BusFault_Handler +UsageFault_Handler +SVC_Handler +DebugMon_Handler +PendSV_Handler +SysTick_Handler +WWDG_IRQHandler +PVD_IRQHandler +TAMPER_IRQHandler +RTC_IRQHandler +FLASH_IRQHandler +RCC_CRS_IRQHandler +EXTI0_IRQHandler +EXTI1_IRQHandler +EXTI2_IRQHandler +EXTI3_IRQHandler +EXTI4_IRQHandler +DMA1_CH1_IRQHandler +DMA1_CH2_IRQHandler +DMA1_CH3_IRQHandler +DMA1_CH4_IRQHandler +DMA1_CH5_IRQHandler +DMA1_CH6_IRQHandler +DMA1_CH7_IRQHandler +ADC1_2_IRQHandler +FlashCache_IRQHandler +CAN1_RX_IRQHandler +EXTI9_5_IRQHandler +TIM1_BRK_IRQHandler +TIM1_UP_IRQHandler +TIM1_TRG_COM_IRQHandler +TIM1_CC_IRQHandler +TIM2_IRQHandler +TIM3_IRQHandler +TIM4_IRQHandler +I2C1_IRQHandler +I2C2_IRQHandler +SPI1_IRQHandler +SPI2_IRQHandler +UART1_IRQHandler +UART2_IRQHandler +UART3_IRQHandler +EXTI15_10_IRQHandler +RTCAlarm_IRQHandler +OTG_FS_WKUP_IRQHandler +TIM8_BRK_IRQHandler +TIM8_UP_IRQHandler +TIM8_TRG_COM_IRQHandler +TIM8_CC_IRQHandler +ADC3_IRQHandler +SDIO_IRQHandler +TIM5_IRQHandler +SPI3_IRQHandler +UART4_IRQHandler +UART5_IRQHandler +TIM6_IRQHandler +TIM7_IRQHandler +DMA2_CH1_IRQHandler +DMA2_CH2_IRQHandler +DMA2_CH3_IRQHandler +DMA2_CH4_IRQHandler +DMA2_CH5_IRQHandler +COMP1_2_IRQHandler +OTG_FS_IRQHandler +UART6_IRQHandler +UART7_IRQHandler +UART8_IRQHandler + + +Default_Handler + B . + END diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/system_mm32f3277g.c b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/system_mm32f3277g.c new file mode 100644 index 0000000000..5e1c1cfd72 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/system_mm32f3277g.c @@ -0,0 +1,16 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#include "hal_device_registers.h" + +void SystemInit(void) +{ + +} + +/* EOF. */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_common_tables.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_common_tables.h new file mode 100644 index 0000000000..6a4337f7e8 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_common_tables.h @@ -0,0 +1,378 @@ +/* ---------------------------------------------------------------------- + * Project: CMSIS DSP Library + * Title: arm_common_tables.h + * Description: Extern declaration for common tables + * + * $Date: 27. January 2017 + * $Revision: V.1.5.1 + * + * Target Processor: Cortex-M cores + * -------------------------------------------------------------------- */ +/* + * Copyright (C) 2010-2017 ARM Limited or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _ARM_COMMON_TABLES_H +#define _ARM_COMMON_TABLES_H + +#include "arm_math.h" + +#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FFT_ALLOW_TABLES) + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREV_1024) + extern const uint16_t armBitRevTable[1024]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_16) + extern const float32_t twiddleCoef_16[32]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_32) + extern const float32_t twiddleCoef_32[64]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_64) + extern const float32_t twiddleCoef_64[128]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_128) + extern const float32_t twiddleCoef_128[256]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_256) + extern const float32_t twiddleCoef_256[512]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_512) + extern const float32_t twiddleCoef_512[1024]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_1024) + extern const float32_t twiddleCoef_1024[2048]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_2048) + extern const float32_t twiddleCoef_2048[4096]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_4096) + extern const float32_t twiddleCoef_4096[8192]; + #define twiddleCoef twiddleCoef_4096 + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_16) + extern const q31_t twiddleCoef_16_q31[24]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_32) + extern const q31_t twiddleCoef_32_q31[48]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_64) + extern const q31_t twiddleCoef_64_q31[96]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_128) + extern const q31_t twiddleCoef_128_q31[192]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_256) + extern const q31_t twiddleCoef_256_q31[384]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_512) + extern const q31_t twiddleCoef_512_q31[768]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_1024) + extern const q31_t twiddleCoef_1024_q31[1536]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_2048) + extern const q31_t twiddleCoef_2048_q31[3072]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_4096) + extern const q31_t twiddleCoef_4096_q31[6144]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_16) + extern const q15_t twiddleCoef_16_q15[24]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_32) + extern const q15_t twiddleCoef_32_q15[48]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_64) + extern const q15_t twiddleCoef_64_q15[96]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_128) + extern const q15_t twiddleCoef_128_q15[192]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_256) + extern const q15_t twiddleCoef_256_q15[384]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_512) + extern const q15_t twiddleCoef_512_q15[768]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_1024) + extern const q15_t twiddleCoef_1024_q15[1536]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_2048) + extern const q15_t twiddleCoef_2048_q15[3072]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_4096) + extern const q15_t twiddleCoef_4096_q15[6144]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_32) + extern const float32_t twiddleCoef_rfft_32[32]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_64) + extern const float32_t twiddleCoef_rfft_64[64]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_128) + extern const float32_t twiddleCoef_rfft_128[128]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_256) + extern const float32_t twiddleCoef_rfft_256[256]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_512) + extern const float32_t twiddleCoef_rfft_512[512]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_1024) + extern const float32_t twiddleCoef_rfft_1024[1024]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_2048) + extern const float32_t twiddleCoef_rfft_2048[2048]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_4096) + extern const float32_t twiddleCoef_rfft_4096[4096]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + /* floating-point bit reversal tables */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_16) + #define ARMBITREVINDEXTABLE_16_TABLE_LENGTH ((uint16_t)20) + extern const uint16_t armBitRevIndexTable16[ARMBITREVINDEXTABLE_16_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_32) + #define ARMBITREVINDEXTABLE_32_TABLE_LENGTH ((uint16_t)48) + extern const uint16_t armBitRevIndexTable32[ARMBITREVINDEXTABLE_32_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_64) + #define ARMBITREVINDEXTABLE_64_TABLE_LENGTH ((uint16_t)56) + extern const uint16_t armBitRevIndexTable64[ARMBITREVINDEXTABLE_64_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_128) + #define ARMBITREVINDEXTABLE_128_TABLE_LENGTH ((uint16_t)208) + extern const uint16_t armBitRevIndexTable128[ARMBITREVINDEXTABLE_128_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_256) + #define ARMBITREVINDEXTABLE_256_TABLE_LENGTH ((uint16_t)440) + extern const uint16_t armBitRevIndexTable256[ARMBITREVINDEXTABLE_256_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_512) + #define ARMBITREVINDEXTABLE_512_TABLE_LENGTH ((uint16_t)448) + extern const uint16_t armBitRevIndexTable512[ARMBITREVINDEXTABLE_512_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_1024) + #define ARMBITREVINDEXTABLE_1024_TABLE_LENGTH ((uint16_t)1800) + extern const uint16_t armBitRevIndexTable1024[ARMBITREVINDEXTABLE_1024_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_2048) + #define ARMBITREVINDEXTABLE_2048_TABLE_LENGTH ((uint16_t)3808) + extern const uint16_t armBitRevIndexTable2048[ARMBITREVINDEXTABLE_2048_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_4096) + #define ARMBITREVINDEXTABLE_4096_TABLE_LENGTH ((uint16_t)4032) + extern const uint16_t armBitRevIndexTable4096[ARMBITREVINDEXTABLE_4096_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + + /* fixed-point bit reversal tables */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_16) + #define ARMBITREVINDEXTABLE_FIXED_16_TABLE_LENGTH ((uint16_t)12) + extern const uint16_t armBitRevIndexTable_fixed_16[ARMBITREVINDEXTABLE_FIXED_16_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_32) + #define ARMBITREVINDEXTABLE_FIXED_32_TABLE_LENGTH ((uint16_t)24) + extern const uint16_t armBitRevIndexTable_fixed_32[ARMBITREVINDEXTABLE_FIXED_32_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_64) + #define ARMBITREVINDEXTABLE_FIXED_64_TABLE_LENGTH ((uint16_t)56) + extern const uint16_t armBitRevIndexTable_fixed_64[ARMBITREVINDEXTABLE_FIXED_64_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_128) + #define ARMBITREVINDEXTABLE_FIXED_128_TABLE_LENGTH ((uint16_t)112) + extern const uint16_t armBitRevIndexTable_fixed_128[ARMBITREVINDEXTABLE_FIXED_128_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_256) + #define ARMBITREVINDEXTABLE_FIXED_256_TABLE_LENGTH ((uint16_t)240) + extern const uint16_t armBitRevIndexTable_fixed_256[ARMBITREVINDEXTABLE_FIXED_256_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_512) + #define ARMBITREVINDEXTABLE_FIXED_512_TABLE_LENGTH ((uint16_t)480) + extern const uint16_t armBitRevIndexTable_fixed_512[ARMBITREVINDEXTABLE_FIXED_512_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_1024) + #define ARMBITREVINDEXTABLE_FIXED_1024_TABLE_LENGTH ((uint16_t)992) + extern const uint16_t armBitRevIndexTable_fixed_1024[ARMBITREVINDEXTABLE_FIXED_1024_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_2048) + #define ARMBITREVINDEXTABLE_FIXED_2048_TABLE_LENGTH ((uint16_t)1984) + extern const uint16_t armBitRevIndexTable_fixed_2048[ARMBITREVINDEXTABLE_FIXED_2048_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_4096) + #define ARMBITREVINDEXTABLE_FIXED_4096_TABLE_LENGTH ((uint16_t)4032) + extern const uint16_t armBitRevIndexTable_fixed_4096[ARMBITREVINDEXTABLE_FIXED_4096_TABLE_LENGTH]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_REALCOEF_F32) + extern const float32_t realCoefA[8192]; + extern const float32_t realCoefB[8192]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_REALCOEF_Q31) + extern const q31_t realCoefAQ31[8192]; + extern const q31_t realCoefBQ31[8192]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_REALCOEF_Q15) + extern const q15_t realCoefAQ15[8192]; + extern const q15_t realCoefBQ15[8192]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_F32_128) + extern const float32_t Weights_128[256]; + extern const float32_t cos_factors_128[128]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_F32_512) + extern const float32_t Weights_512[1024]; + extern const float32_t cos_factors_512[512]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_F32_2048) + extern const float32_t Weights_2048[4096]; + extern const float32_t cos_factors_2048[2048]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_F32_8192) + extern const float32_t Weights_8192[16384]; + extern const float32_t cos_factors_8192[8192]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q15_128) + extern const q15_t WeightsQ15_128[256]; + extern const q15_t cos_factorsQ15_128[128]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q15_512) + extern const q15_t WeightsQ15_512[1024]; + extern const q15_t cos_factorsQ15_512[512]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q15_2048) + extern const q15_t WeightsQ15_2048[4096]; + extern const q15_t cos_factorsQ15_2048[2048]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q15_8192) + extern const q15_t WeightsQ15_8192[16384]; + extern const q15_t cos_factorsQ15_8192[8192]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_128) + extern const q31_t WeightsQ31_128[256]; + extern const q31_t cos_factorsQ31_128[128]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_512) + extern const q31_t WeightsQ31_512[1024]; + extern const q31_t cos_factorsQ31_512[512]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_2048) + extern const q31_t WeightsQ31_2048[4096]; + extern const q31_t cos_factorsQ31_2048[2048]; + #endif + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_8192) + extern const q31_t WeightsQ31_8192[16384]; + extern const q31_t cos_factorsQ31_8192[8192]; + #endif + +#endif /* if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FFT_TABLES) */ + +#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FAST_ALLOW_TABLES) + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_RECIP_Q15) + extern const q15_t armRecipTableQ15[64]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_RECIP_Q31) + extern const q31_t armRecipTableQ31[64]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */ + + /* Tables for Fast Math Sine and Cosine */ + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_SIN_F32) + extern const float32_t sinTable_f32[FAST_MATH_TABLE_SIZE + 1]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_SIN_Q31) + extern const q31_t sinTable_q31[FAST_MATH_TABLE_SIZE + 1]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */ + + #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_SIN_Q15) + extern const q15_t sinTable_q15[FAST_MATH_TABLE_SIZE + 1]; + #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */ + +#endif /* if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FAST_TABLES) */ + +#endif /* ARM_COMMON_TABLES_H */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_const_structs.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_const_structs.h new file mode 100644 index 0000000000..80a3e8bbe7 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_const_structs.h @@ -0,0 +1,66 @@ +/* ---------------------------------------------------------------------- + * Project: CMSIS DSP Library + * Title: arm_const_structs.h + * Description: Constant structs that are initialized for user convenience. + * For example, some can be given as arguments to the arm_cfft_f32() function. + * + * $Date: 27. January 2017 + * $Revision: V.1.5.1 + * + * Target Processor: Cortex-M cores + * -------------------------------------------------------------------- */ +/* + * Copyright (C) 2010-2017 ARM Limited or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _ARM_CONST_STRUCTS_H +#define _ARM_CONST_STRUCTS_H + +#include "arm_math.h" +#include "arm_common_tables.h" + + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len16; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len32; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len64; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len128; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len256; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len512; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len1024; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len2048; + extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len4096; + + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len16; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len32; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len64; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len128; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len256; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len512; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len1024; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len2048; + extern const arm_cfft_instance_q31 arm_cfft_sR_q31_len4096; + + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len16; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len32; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len64; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len128; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len256; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len512; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len1024; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len2048; + extern const arm_cfft_instance_q15 arm_cfft_sR_q15_len4096; + +#endif diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_math.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_math.h new file mode 100644 index 0000000000..eb37f8223c --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/arm_math.h @@ -0,0 +1,7361 @@ +/****************************************************************************** + * @file arm_math.h + * @brief Public header file for CMSIS DSP Library + * @version V1.6.0 + * @date 18. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2010-2019 Arm Limited or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + \mainpage CMSIS DSP Software Library + * + * Introduction + * ------------ + * + * This user manual describes the CMSIS DSP software library, + * a suite of common signal processing functions for use on Cortex-M processor based devices. + * + * The library is divided into a number of functions each covering a specific category: + * - Basic math functions + * - Fast math functions + * - Complex math functions + * - Filters + * - Matrix functions + * - Transform functions + * - Motor control functions + * - Statistical functions + * - Support functions + * - Interpolation functions + * + * The library has separate functions for operating on 8-bit integers, 16-bit integers, + * 32-bit integer and 32-bit floating-point values. + * + * Using the Library + * ------------ + * + * The library installer contains prebuilt versions of the libraries in the Lib folder. + * - arm_cortexM7lfdp_math.lib (Cortex-M7, Little endian, Double Precision Floating Point Unit) + * - arm_cortexM7bfdp_math.lib (Cortex-M7, Big endian, Double Precision Floating Point Unit) + * - arm_cortexM7lfsp_math.lib (Cortex-M7, Little endian, Single Precision Floating Point Unit) + * - arm_cortexM7bfsp_math.lib (Cortex-M7, Big endian and Single Precision Floating Point Unit on) + * - arm_cortexM7l_math.lib (Cortex-M7, Little endian) + * - arm_cortexM7b_math.lib (Cortex-M7, Big endian) + * - arm_cortexM4lf_math.lib (Cortex-M4, Little endian, Floating Point Unit) + * - arm_cortexM4bf_math.lib (Cortex-M4, Big endian, Floating Point Unit) + * - arm_cortexM4l_math.lib (Cortex-M4, Little endian) + * - arm_cortexM4b_math.lib (Cortex-M4, Big endian) + * - arm_cortexM3l_math.lib (Cortex-M3, Little endian) + * - arm_cortexM3b_math.lib (Cortex-M3, Big endian) + * - arm_cortexM0l_math.lib (Cortex-M0 / Cortex-M0+, Little endian) + * - arm_cortexM0b_math.lib (Cortex-M0 / Cortex-M0+, Big endian) + * - arm_ARMv8MBLl_math.lib (Armv8-M Baseline, Little endian) + * - arm_ARMv8MMLl_math.lib (Armv8-M Mainline, Little endian) + * - arm_ARMv8MMLlfsp_math.lib (Armv8-M Mainline, Little endian, Single Precision Floating Point Unit) + * - arm_ARMv8MMLld_math.lib (Armv8-M Mainline, Little endian, DSP instructions) + * - arm_ARMv8MMLldfsp_math.lib (Armv8-M Mainline, Little endian, DSP instructions, Single Precision Floating Point Unit) + * + * The library functions are declared in the public file arm_math.h which is placed in the Include folder. + * Simply include this file and link the appropriate library in the application and begin calling the library functions. The Library supports single + * public header file arm_math.h for Cortex-M cores with little endian and big endian. Same header file will be used for floating point unit(FPU) variants. + * + * + * Examples + * -------- + * + * The library ships with a number of examples which demonstrate how to use the library functions. + * + * Toolchain Support + * ------------ + * + * The library has been developed and tested with MDK version 5.14.0.0 + * The library is being tested in GCC and IAR toolchains and updates on this activity will be made available shortly. + * + * Building the Library + * ------------ + * + * The library installer contains a project file to rebuild libraries on MDK toolchain in the CMSIS\\DSP\\Projects\\ARM folder. + * - arm_cortexM_math.uvprojx + * + * + * The libraries can be built by opening the arm_cortexM_math.uvprojx project in MDK-ARM, selecting a specific target, and defining the optional preprocessor macros detailed above. + * + * Preprocessor Macros + * ------------ + * + * Each library project have different preprocessor macros. + * + * - ARM_MATH_BIG_ENDIAN: + * + * Define macro ARM_MATH_BIG_ENDIAN to build the library for big endian targets. By default library builds for little endian targets. + * + * - ARM_MATH_MATRIX_CHECK: + * + * Define macro ARM_MATH_MATRIX_CHECK for checking on the input and output sizes of matrices + * + * - ARM_MATH_ROUNDING: + * + * Define macro ARM_MATH_ROUNDING for rounding on support functions + * + * - ARM_MATH_LOOPUNROLL: + * + * Define macro ARM_MATH_LOOPUNROLL to enable manual loop unrolling in DSP functions + * + * - ARM_MATH_NEON: + * + * Define macro ARM_MATH_NEON to enable Neon versions of the DSP functions. + * It is not enabled by default when Neon is available because performances are + * dependent on the compiler and target architecture. + * + * - ARM_MATH_NEON_EXPERIMENTAL: + * + * Define macro ARM_MATH_NEON_EXPERIMENTAL to enable experimental Neon versions of + * of some DSP functions. Experimental Neon versions currently do not have better + * performances than the scalar versions. + * + *
+ * CMSIS-DSP in ARM::CMSIS Pack + * ----------------------------- + * + * The following files relevant to CMSIS-DSP are present in the ARM::CMSIS Pack directories: + * |File/Folder |Content | + * |---------------------------------|------------------------------------------------------------------------| + * |\b CMSIS\\Documentation\\DSP | This documentation | + * |\b CMSIS\\DSP\\DSP_Lib_TestSuite | DSP_Lib test suite | + * |\b CMSIS\\DSP\\Examples | Example projects demonstrating the usage of the library functions | + * |\b CMSIS\\DSP\\Include | DSP_Lib include files | + * |\b CMSIS\\DSP\\Lib | DSP_Lib binaries | + * |\b CMSIS\\DSP\\Projects | Projects to rebuild DSP_Lib binaries | + * |\b CMSIS\\DSP\\Source | DSP_Lib source files | + * + *
+ * Revision History of CMSIS-DSP + * ------------ + * Please refer to \ref ChangeLog_pg. + */ + + +/** + * @defgroup groupMath Basic Math Functions + */ + +/** + * @defgroup groupFastMath Fast Math Functions + * This set of functions provides a fast approximation to sine, cosine, and square root. + * As compared to most of the other functions in the CMSIS math library, the fast math functions + * operate on individual values and not arrays. + * There are separate functions for Q15, Q31, and floating-point data. + * + */ + +/** + * @defgroup groupCmplxMath Complex Math Functions + * This set of functions operates on complex data vectors. + * The data in the complex arrays is stored in an interleaved fashion + * (real, imag, real, imag, ...). + * In the API functions, the number of samples in a complex array refers + * to the number of complex values; the array contains twice this number of + * real values. + */ + +/** + * @defgroup groupFilters Filtering Functions + */ + +/** + * @defgroup groupMatrix Matrix Functions + * + * This set of functions provides basic matrix math operations. + * The functions operate on matrix data structures. For example, + * the type + * definition for the floating-point matrix structure is shown + * below: + * 
+ *     typedef struct
+ *     {
+ *       uint16_t numRows;     // number of rows of the matrix.
+ *       uint16_t numCols;     // number of columns of the matrix.
+ *       float32_t *pData;     // points to the data of the matrix.
+ *     } arm_matrix_instance_f32;
+ *
+ * There are similar definitions for Q15 and Q31 data types. + * + * The structure specifies the size of the matrix and then points to + * an array of data. The array is of size numRows X numCols + * and the values are arranged in row order. That is, the + * matrix element (i, j) is stored at: + * 
+ *     pData[i*numCols + j]
+ *
+ * + * \par Init Functions + * There is an associated initialization function for each type of matrix + * data structure. + * The initialization function sets the values of the internal structure fields. + * Refer to \ref arm_mat_init_f32(), \ref arm_mat_init_q31() and \ref arm_mat_init_q15() + * for floating-point, Q31 and Q15 types, respectively. + * + * \par + * Use of the initialization function is optional. However, if initialization function is used + * then the instance structure cannot be placed into a const data section. + * To place the instance structure in a const data + * section, manually initialize the data structure. For example: + * 
+ * arm_matrix_instance_f32 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q31 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q15 S = {nRows, nColumns, pData};
+ *
+ * where nRows specifies the number of rows, nColumns + * specifies the number of columns, and pData points to the + * data array. + * + * \par Size Checking + * By default all of the matrix functions perform size checking on the input and + * output matrices. For example, the matrix addition function verifies that the + * two input matrices and the output matrix all have the same number of rows and + * columns. If the size check fails the functions return: + * 
+ *     ARM_MATH_SIZE_MISMATCH
+ *
+ * Otherwise the functions return + * 
+ *     ARM_MATH_SUCCESS
+ *
+ * There is some overhead associated with this matrix size checking. + * The matrix size checking is enabled via the \#define + * 
+ *     ARM_MATH_MATRIX_CHECK
+ *
+ * within the library project settings. By default this macro is defined + * and size checking is enabled. By changing the project settings and + * undefining this macro size checking is eliminated and the functions + * run a bit faster. With size checking disabled the functions always + * return ARM_MATH_SUCCESS. + */ + +/** + * @defgroup groupTransforms Transform Functions + */ + +/** + * @defgroup groupController Controller Functions + */ + +/** + * @defgroup groupStats Statistics Functions + */ + +/** + * @defgroup groupSupport Support Functions + */ + +/** + * @defgroup groupInterpolation Interpolation Functions + * These functions perform 1- and 2-dimensional interpolation of data. + * Linear interpolation is used for 1-dimensional data and + * bilinear interpolation is used for 2-dimensional data. + */ + +/** + * @defgroup groupExamples Examples + */ + + +#ifndef _ARM_MATH_H +#define _ARM_MATH_H + +/* Compiler specific diagnostic adjustment */ +#if defined ( __CC_ARM ) + +#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 ) + +#elif defined ( __GNUC__ ) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wsign-conversion" + #pragma GCC diagnostic ignored "-Wconversion" + #pragma GCC diagnostic ignored "-Wunused-parameter" + +#elif defined ( __ICCARM__ ) + +#elif defined ( __TI_ARM__ ) + +#elif defined ( __CSMC__ ) + +#elif defined ( __TASKING__ ) + +#elif defined ( _MSC_VER ) + +#else + #error Unknown compiler +#endif + + +/* Included for instrinsics definitions */ +#if !defined ( _MSC_VER ) +#include "cmsis_compiler.h" +#else +#include +#define __STATIC_FORCEINLINE static __forceinline +#define __ALIGNED(x) __declspec(align(x)) +#define LOW_OPTIMIZATION_ENTER +#define LOW_OPTIMIZATION_EXIT +#define IAR_ONLY_LOW_OPTIMIZATION_ENTER +#define IAR_ONLY_LOW_OPTIMIZATION_EXIT +#endif + +#include "string.h" +#include "math.h" +#include "float.h" + +/* evaluate ARM DSP feature */ +#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1)) + #define ARM_MATH_DSP 1 +#endif + +#if defined(__ARM_NEON) +#include +#endif + + +#ifdef __cplusplus +extern "C" +{ +#endif + + + /** + * @brief Macros required for reciprocal calculation in Normalized LMS + */ + +#define DELTA_Q31 (0x100) +#define DELTA_Q15 0x5 +#define INDEX_MASK 0x0000003F +#ifndef PI + #define PI 3.14159265358979f +#endif + + /** + * @brief Macros required for SINE and COSINE Fast math approximations + */ + +#define FAST_MATH_TABLE_SIZE 512 +#define FAST_MATH_Q31_SHIFT (32 - 10) +#define FAST_MATH_Q15_SHIFT (16 - 10) +#define CONTROLLER_Q31_SHIFT (32 - 9) +#define TABLE_SPACING_Q31 0x400000 +#define TABLE_SPACING_Q15 0x80 + + /** + * @brief Macros required for SINE and COSINE Controller functions + */ + /* 1.31(q31) Fixed value of 2/360 */ + /* -1 to +1 is divided into 360 values so total spacing is (2/360) */ +#define INPUT_SPACING 0xB60B61 + + + /** + * @brief Error status returned by some functions in the library. + */ + + typedef enum + { + ARM_MATH_SUCCESS = 0, /**< No error */ + ARM_MATH_ARGUMENT_ERROR = -1, /**< One or more arguments are incorrect */ + ARM_MATH_LENGTH_ERROR = -2, /**< Length of data buffer is incorrect */ + ARM_MATH_SIZE_MISMATCH = -3, /**< Size of matrices is not compatible with the operation */ + ARM_MATH_NANINF = -4, /**< Not-a-number (NaN) or infinity is generated */ + ARM_MATH_SINGULAR = -5, /**< Input matrix is singular and cannot be inverted */ + ARM_MATH_TEST_FAILURE = -6 /**< Test Failed */ + } arm_status; + + /** + * @brief 8-bit fractional data type in 1.7 format. + */ + typedef int8_t q7_t; + + /** + * @brief 16-bit fractional data type in 1.15 format. + */ + typedef int16_t q15_t; + + /** + * @brief 32-bit fractional data type in 1.31 format. + */ + typedef int32_t q31_t; + + /** + * @brief 64-bit fractional data type in 1.63 format. + */ + typedef int64_t q63_t; + + /** + * @brief 32-bit floating-point type definition. + */ + typedef float float32_t; + + /** + * @brief 64-bit floating-point type definition. + */ + typedef double float64_t; + + +/** + @brief definition to read/write two 16 bit values. + @deprecated + */ +#if defined ( __CC_ARM ) + #define __SIMD32_TYPE int32_t __packed +#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 ) + #define __SIMD32_TYPE int32_t +#elif defined ( __GNUC__ ) + #define __SIMD32_TYPE int32_t +#elif defined ( __ICCARM__ ) + #define __SIMD32_TYPE int32_t __packed +#elif defined ( __TI_ARM__ ) + #define __SIMD32_TYPE int32_t +#elif defined ( __CSMC__ ) + #define __SIMD32_TYPE int32_t +#elif defined ( __TASKING__ ) + #define __SIMD32_TYPE __un(aligned) int32_t +#elif defined(_MSC_VER ) + #define __SIMD32_TYPE int32_t +#else + #error Unknown compiler +#endif + +#define __SIMD32(addr) (*(__SIMD32_TYPE **) & (addr)) +#define __SIMD32_CONST(addr) ( (__SIMD32_TYPE * ) (addr)) +#define _SIMD32_OFFSET(addr) (*(__SIMD32_TYPE * ) (addr)) +#define __SIMD64(addr) (*( int64_t **) & (addr)) + +/* SIMD replacement */ + + +/** + @brief Read 2 Q15 from Q15 pointer. + @param[in] pQ15 points to input value + @return Q31 value + */ +__STATIC_FORCEINLINE q31_t read_q15x2 ( + q15_t * pQ15) +{ + q31_t val; + + memcpy (&val, pQ15, 4); + + return (val); +} + +/** + @brief Read 2 Q15 from Q15 pointer and increment pointer afterwards. + @param[in] pQ15 points to input value + @return Q31 value + */ +__STATIC_FORCEINLINE q31_t read_q15x2_ia ( + q15_t ** pQ15) +{ + q31_t val; + + memcpy (&val, *pQ15, 4); + *pQ15 += 2; + + return (val); +} + +/** + @brief Read 2 Q15 from Q15 pointer and decrement pointer afterwards. + @param[in] pQ15 points to input value + @return Q31 value + */ +__STATIC_FORCEINLINE q31_t read_q15x2_da ( + q15_t ** pQ15) +{ + q31_t val; + + memcpy (&val, *pQ15, 4); + *pQ15 -= 2; + + return (val); +} + +/** + @brief Write 2 Q15 to Q15 pointer and increment pointer afterwards. + @param[in] pQ15 points to input value + @param[in] value Q31 value + @return none + */ +__STATIC_FORCEINLINE void write_q15x2_ia ( + q15_t ** pQ15, + q31_t value) +{ + q31_t val = value; + + memcpy (*pQ15, &val, 4); + *pQ15 += 2; +} + +/** + @brief Write 2 Q15 to Q15 pointer. + @param[in] pQ15 points to input value + @param[in] value Q31 value + @return none + */ +__STATIC_FORCEINLINE void write_q15x2 ( + q15_t * pQ15, + q31_t value) +{ + q31_t val = value; + + memcpy (pQ15, &val, 4); +} + + +/** + @brief Read 4 Q7 from Q7 pointer and increment pointer afterwards. + @param[in] pQ7 points to input value + @return Q31 value + */ +__STATIC_FORCEINLINE q31_t read_q7x4_ia ( + q7_t ** pQ7) +{ + q31_t val; + + memcpy (&val, *pQ7, 4); + *pQ7 += 4; + + return (val); +} + +/** + @brief Read 4 Q7 from Q7 pointer and decrement pointer afterwards. + @param[in] pQ7 points to input value + @return Q31 value + */ +__STATIC_FORCEINLINE q31_t read_q7x4_da ( + q7_t ** pQ7) +{ + q31_t val; + + memcpy (&val, *pQ7, 4); + *pQ7 -= 4; + + return (val); +} + +/** + @brief Write 4 Q7 to Q7 pointer and increment pointer afterwards. + @param[in] pQ7 points to input value + @param[in] value Q31 value + @return none + */ +__STATIC_FORCEINLINE void write_q7x4_ia ( + q7_t ** pQ7, + q31_t value) +{ + q31_t val = value; + + memcpy (*pQ7, &val, 4); + *pQ7 += 4; +} + +/* + +Normally those kind of definitions are in a compiler file +in Core or Core_A. + +But for MSVC compiler it is a bit special. The goal is very specific +to CMSIS-DSP and only to allow the use of this library from other +systems like Python or Matlab. + +MSVC is not going to be used to cross-compile to ARM. So, having a MSVC +compiler file in Core or Core_A would not make sense. + +*/ +#if defined ( _MSC_VER ) + __STATIC_FORCEINLINE uint8_t __CLZ(uint32_t data) + { + if (data == 0U) { return 32U; } + + uint32_t count = 0U; + uint32_t mask = 0x80000000U; + + while ((data & mask) == 0U) + { + count += 1U; + mask = mask >> 1U; + } + return count; + } + + __STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat) + { + if ((sat >= 1U) && (sat <= 32U)) + { + const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U); + const int32_t min = -1 - max ; + if (val > max) + { + return max; + } + else if (val < min) + { + return min; + } + } + return val; + } + + __STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat) + { + if (sat <= 31U) + { + const uint32_t max = ((1U << sat) - 1U); + if (val > (int32_t)max) + { + return max; + } + else if (val < 0) + { + return 0U; + } + } + return (uint32_t)val; + } +#endif + +#ifndef ARM_MATH_DSP + /** + * @brief definition to pack two 16 bit values. + */ + #define __PKHBT(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0x0000FFFF) | \ + (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000) ) + #define __PKHTB(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0xFFFF0000) | \ + (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF) ) +#endif + + /** + * @brief definition to pack four 8 bit values. + */ +#ifndef ARM_MATH_BIG_ENDIAN + #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) << 0) & (int32_t)0x000000FF) | \ + (((int32_t)(v1) << 8) & (int32_t)0x0000FF00) | \ + (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) | \ + (((int32_t)(v3) << 24) & (int32_t)0xFF000000) ) +#else + #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) << 0) & (int32_t)0x000000FF) | \ + (((int32_t)(v2) << 8) & (int32_t)0x0000FF00) | \ + (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) | \ + (((int32_t)(v0) << 24) & (int32_t)0xFF000000) ) +#endif + + + /** + * @brief Clips Q63 to Q31 values. + */ + __STATIC_FORCEINLINE q31_t clip_q63_to_q31( + q63_t x) + { + return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? + ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x; + } + + /** + * @brief Clips Q63 to Q15 values. + */ + __STATIC_FORCEINLINE q15_t clip_q63_to_q15( + q63_t x) + { + return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? + ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15); + } + + /** + * @brief Clips Q31 to Q7 values. + */ + __STATIC_FORCEINLINE q7_t clip_q31_to_q7( + q31_t x) + { + return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ? + ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x; + } + + /** + * @brief Clips Q31 to Q15 values. + */ + __STATIC_FORCEINLINE q15_t clip_q31_to_q15( + q31_t x) + { + return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ? + ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x; + } + + /** + * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format. + */ + __STATIC_FORCEINLINE q63_t mult32x64( + q63_t x, + q31_t y) + { + return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) + + (((q63_t) (x >> 32) * y) ) ); + } + + /** + * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type. + */ + __STATIC_FORCEINLINE uint32_t arm_recip_q31( + q31_t in, + q31_t * dst, + const q31_t * pRecipTable) + { + q31_t out; + uint32_t tempVal; + uint32_t index, i; + uint32_t signBits; + + if (in > 0) + { + signBits = ((uint32_t) (__CLZ( in) - 1)); + } + else + { + signBits = ((uint32_t) (__CLZ(-in) - 1)); + } + + /* Convert input sample to 1.31 format */ + in = (in << signBits); + + /* calculation of index for initial approximated Val */ + index = (uint32_t)(in >> 24); + index = (index & INDEX_MASK); + + /* 1.31 with exp 1 */ + out = pRecipTable[index]; + + /* calculation of reciprocal value */ + /* running approximation for two iterations */ + for (i = 0U; i < 2U; i++) + { + tempVal = (uint32_t) (((q63_t) in * out) >> 31); + tempVal = 0x7FFFFFFFu - tempVal; + /* 1.31 with exp 1 */ + /* out = (q31_t) (((q63_t) out * tempVal) >> 30); */ + out = clip_q63_to_q31(((q63_t) out * tempVal) >> 30); + } + + /* write output */ + *dst = out; + + /* return num of signbits of out = 1/in value */ + return (signBits + 1U); + } + + + /** + * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type. + */ + __STATIC_FORCEINLINE uint32_t arm_recip_q15( + q15_t in, + q15_t * dst, + const q15_t * pRecipTable) + { + q15_t out = 0; + uint32_t tempVal = 0; + uint32_t index = 0, i = 0; + uint32_t signBits = 0; + + if (in > 0) + { + signBits = ((uint32_t)(__CLZ( in) - 17)); + } + else + { + signBits = ((uint32_t)(__CLZ(-in) - 17)); + } + + /* Convert input sample to 1.15 format */ + in = (in << signBits); + + /* calculation of index for initial approximated Val */ + index = (uint32_t)(in >> 8); + index = (index & INDEX_MASK); + + /* 1.15 with exp 1 */ + out = pRecipTable[index]; + + /* calculation of reciprocal value */ + /* running approximation for two iterations */ + for (i = 0U; i < 2U; i++) + { + tempVal = (uint32_t) (((q31_t) in * out) >> 15); + tempVal = 0x7FFFu - tempVal; + /* 1.15 with exp 1 */ + out = (q15_t) (((q31_t) out * tempVal) >> 14); + /* out = clip_q31_to_q15(((q31_t) out * tempVal) >> 14); */ + } + + /* write output */ + *dst = out; + + /* return num of signbits of out = 1/in value */ + return (signBits + 1); + } + +#if defined(ARM_MATH_NEON) + +static inline float32x4_t __arm_vec_sqrt_f32_neon(float32x4_t x) +{ + float32x4_t x1 = vmaxq_f32(x, vdupq_n_f32(FLT_MIN)); + float32x4_t e = vrsqrteq_f32(x1); + e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x1, e), e), e); + e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x1, e), e), e); + return vmulq_f32(x, e); +} + +static inline int16x8_t __arm_vec_sqrt_q15_neon(int16x8_t vec) +{ + float32x4_t tempF; + int32x4_t tempHI,tempLO; + + tempLO = vmovl_s16(vget_low_s16(vec)); + tempF = vcvtq_n_f32_s32(tempLO,15); + tempF = __arm_vec_sqrt_f32_neon(tempF); + tempLO = vcvtq_n_s32_f32(tempF,15); + + tempHI = vmovl_s16(vget_high_s16(vec)); + tempF = vcvtq_n_f32_s32(tempHI,15); + tempF = __arm_vec_sqrt_f32_neon(tempF); + tempHI = vcvtq_n_s32_f32(tempF,15); + + return(vcombine_s16(vqmovn_s32(tempLO),vqmovn_s32(tempHI))); +} + +static inline int32x4_t __arm_vec_sqrt_q31_neon(int32x4_t vec) +{ + float32x4_t temp; + + temp = vcvtq_n_f32_s32(vec,31); + temp = __arm_vec_sqrt_f32_neon(temp); + return(vcvtq_n_s32_f32(temp,31)); +} + +#endif + +/* + * @brief C custom defined intrinsic functions + */ +#if !defined (ARM_MATH_DSP) + + /* + * @brief C custom defined QADD8 + */ + __STATIC_FORCEINLINE uint32_t __QADD8( + uint32_t x, + uint32_t y) + { + q31_t r, s, t, u; + + r = __SSAT(((((q31_t)x << 24) >> 24) + (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF; + s = __SSAT(((((q31_t)x << 16) >> 24) + (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF; + t = __SSAT(((((q31_t)x << 8) >> 24) + (((q31_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF; + u = __SSAT(((((q31_t)x ) >> 24) + (((q31_t)y ) >> 24)), 8) & (int32_t)0x000000FF; + + return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r ))); + } + + + /* + * @brief C custom defined QSUB8 + */ + __STATIC_FORCEINLINE uint32_t __QSUB8( + uint32_t x, + uint32_t y) + { + q31_t r, s, t, u; + + r = __SSAT(((((q31_t)x << 24) >> 24) - (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF; + s = __SSAT(((((q31_t)x << 16) >> 24) - (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF; + t = __SSAT(((((q31_t)x << 8) >> 24) - (((q31_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF; + u = __SSAT(((((q31_t)x ) >> 24) - (((q31_t)y ) >> 24)), 8) & (int32_t)0x000000FF; + + return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r ))); + } + + + /* + * @brief C custom defined QADD16 + */ + __STATIC_FORCEINLINE uint32_t __QADD16( + uint32_t x, + uint32_t y) + { +/* q31_t r, s; without initialisation 'arm_offset_q15 test' fails but 'intrinsic' tests pass! for armCC */ + q31_t r = 0, s = 0; + + r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; + s = __SSAT(((((q31_t)x ) >> 16) + (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined SHADD16 + */ + __STATIC_FORCEINLINE uint32_t __SHADD16( + uint32_t x, + uint32_t y) + { + q31_t r, s; + + r = (((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; + s = (((((q31_t)x ) >> 16) + (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined QSUB16 + */ + __STATIC_FORCEINLINE uint32_t __QSUB16( + uint32_t x, + uint32_t y) + { + q31_t r, s; + + r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; + s = __SSAT(((((q31_t)x ) >> 16) - (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined SHSUB16 + */ + __STATIC_FORCEINLINE uint32_t __SHSUB16( + uint32_t x, + uint32_t y) + { + q31_t r, s; + + r = (((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; + s = (((((q31_t)x ) >> 16) - (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined QASX + */ + __STATIC_FORCEINLINE uint32_t __QASX( + uint32_t x, + uint32_t y) + { + q31_t r, s; + + r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF; + s = __SSAT(((((q31_t)x ) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined SHASX + */ + __STATIC_FORCEINLINE uint32_t __SHASX( + uint32_t x, + uint32_t y) + { + q31_t r, s; + + r = (((((q31_t)x << 16) >> 16) - (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF; + s = (((((q31_t)x ) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined QSAX + */ + __STATIC_FORCEINLINE uint32_t __QSAX( + uint32_t x, + uint32_t y) + { + q31_t r, s; + + r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF; + s = __SSAT(((((q31_t)x ) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined SHSAX + */ + __STATIC_FORCEINLINE uint32_t __SHSAX( + uint32_t x, + uint32_t y) + { + q31_t r, s; + + r = (((((q31_t)x << 16) >> 16) + (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF; + s = (((((q31_t)x ) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; + + return ((uint32_t)((s << 16) | (r ))); + } + + + /* + * @brief C custom defined SMUSDX + */ + __STATIC_FORCEINLINE uint32_t __SMUSDX( + uint32_t x, + uint32_t y) + { + return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) - + ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) )); + } + + /* + * @brief C custom defined SMUADX + */ + __STATIC_FORCEINLINE uint32_t __SMUADX( + uint32_t x, + uint32_t y) + { + return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) + + ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) )); + } + + + /* + * @brief C custom defined QADD + */ + __STATIC_FORCEINLINE int32_t __QADD( + int32_t x, + int32_t y) + { + return ((int32_t)(clip_q63_to_q31((q63_t)x + (q31_t)y))); + } + + + /* + * @brief C custom defined QSUB + */ + __STATIC_FORCEINLINE int32_t __QSUB( + int32_t x, + int32_t y) + { + return ((int32_t)(clip_q63_to_q31((q63_t)x - (q31_t)y))); + } + + + /* + * @brief C custom defined SMLAD + */ + __STATIC_FORCEINLINE uint32_t __SMLAD( + uint32_t x, + uint32_t y, + uint32_t sum) + { + return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) + + ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) + + ( ((q31_t)sum ) ) )); + } + + + /* + * @brief C custom defined SMLADX + */ + __STATIC_FORCEINLINE uint32_t __SMLADX( + uint32_t x, + uint32_t y, + uint32_t sum) + { + return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) + + ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) + + ( ((q31_t)sum ) ) )); + } + + + /* + * @brief C custom defined SMLSDX + */ + __STATIC_FORCEINLINE uint32_t __SMLSDX( + uint32_t x, + uint32_t y, + uint32_t sum) + { + return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) - + ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) + + ( ((q31_t)sum ) ) )); + } + + + /* + * @brief C custom defined SMLALD + */ + __STATIC_FORCEINLINE uint64_t __SMLALD( + uint32_t x, + uint32_t y, + uint64_t sum) + { +/* return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + ((q15_t) x * (q15_t) y)); */ + return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) + + ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) + + ( ((q63_t)sum ) ) )); + } + + + /* + * @brief C custom defined SMLALDX + */ + __STATIC_FORCEINLINE uint64_t __SMLALDX( + uint32_t x, + uint32_t y, + uint64_t sum) + { +/* return (sum + ((q15_t) (x >> 16) * (q15_t) y)) + ((q15_t) x * (q15_t) (y >> 16)); */ + return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) + + ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) + + ( ((q63_t)sum ) ) )); + } + + + /* + * @brief C custom defined SMUAD + */ + __STATIC_FORCEINLINE uint32_t __SMUAD( + uint32_t x, + uint32_t y) + { + return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) + + ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) )); + } + + + /* + * @brief C custom defined SMUSD + */ + __STATIC_FORCEINLINE uint32_t __SMUSD( + uint32_t x, + uint32_t y) + { + return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) - + ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) )); + } + + + /* + * @brief C custom defined SXTB16 + */ + __STATIC_FORCEINLINE uint32_t __SXTB16( + uint32_t x) + { + return ((uint32_t)(((((q31_t)x << 24) >> 24) & (q31_t)0x0000FFFF) | + ((((q31_t)x << 8) >> 8) & (q31_t)0xFFFF0000) )); + } + + /* + * @brief C custom defined SMMLA + */ + __STATIC_FORCEINLINE int32_t __SMMLA( + int32_t x, + int32_t y, + int32_t sum) + { + return (sum + (int32_t) (((int64_t) x * y) >> 32)); + } + +#endif /* !defined (ARM_MATH_DSP) */ + + + /** + * @brief Instance structure for the Q7 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q7_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + const q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + } arm_fir_instance_q7; + + /** + * @brief Instance structure for the Q15 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + } arm_fir_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + } arm_fir_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + } arm_fir_instance_f32; + + /** + * @brief Processing function for the Q7 FIR filter. + * @param[in] S points to an instance of the Q7 FIR filter structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_fir_q7( + const arm_fir_instance_q7 * S, + const q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q7 FIR filter. + * @param[in,out] S points to an instance of the Q7 FIR structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of samples that are processed. + */ + void arm_fir_init_q7( + arm_fir_instance_q7 * S, + uint16_t numTaps, + const q7_t * pCoeffs, + q7_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q15 FIR filter. + * @param[in] S points to an instance of the Q15 FIR structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_fir_q15( + const arm_fir_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the fast Q15 FIR filter (fast version). + * @param[in] S points to an instance of the Q15 FIR filter structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_fir_fast_q15( + const arm_fir_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q15 FIR filter. + * @param[in,out] S points to an instance of the Q15 FIR filter structure. + * @param[in] numTaps Number of filter coefficients in the filter. Must be even and greater than or equal to 4. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + * @return The function returns either + * ARM_MATH_SUCCESS if initialization was successful or + * ARM_MATH_ARGUMENT_ERROR if numTaps is not a supported value. + */ + arm_status arm_fir_init_q15( + arm_fir_instance_q15 * S, + uint16_t numTaps, + const q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR filter. + * @param[in] S points to an instance of the Q31 FIR filter structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_fir_q31( + const arm_fir_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the fast Q31 FIR filter (fast version). + * @param[in] S points to an instance of the Q31 FIR filter structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_fir_fast_q31( + const arm_fir_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 FIR filter. + * @param[in,out] S points to an instance of the Q31 FIR structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + */ + void arm_fir_init_q31( + arm_fir_instance_q31 * S, + uint16_t numTaps, + const q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the floating-point FIR filter. + * @param[in] S points to an instance of the floating-point FIR structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_fir_f32( + const arm_fir_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point FIR filter. + * @param[in,out] S points to an instance of the floating-point FIR filter structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + */ + void arm_fir_init_f32( + arm_fir_instance_f32 * S, + uint16_t numTaps, + const float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + /** + * @brief Instance structure for the Q15 Biquad cascade filter. + */ + typedef struct + { + int8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q15_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + const q15_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + int8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ + } arm_biquad_casd_df1_inst_q15; + + /** + * @brief Instance structure for the Q31 Biquad cascade filter. + */ + typedef struct + { + uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q31_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + const q31_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + uint8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ + } arm_biquad_casd_df1_inst_q31; + + /** + * @brief Instance structure for the floating-point Biquad cascade filter. + */ + typedef struct + { + uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float32_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + const float32_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + } arm_biquad_casd_df1_inst_f32; + + /** + * @brief Processing function for the Q15 Biquad cascade filter. + * @param[in] S points to an instance of the Q15 Biquad cascade structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_df1_q15( + const arm_biquad_casd_df1_inst_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q15 Biquad cascade filter. + * @param[in,out] S points to an instance of the Q15 Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format + */ + void arm_biquad_cascade_df1_init_q15( + arm_biquad_casd_df1_inst_q15 * S, + uint8_t numStages, + const q15_t * pCoeffs, + q15_t * pState, + int8_t postShift); + + /** + * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4. + * @param[in] S points to an instance of the Q15 Biquad cascade structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_df1_fast_q15( + const arm_biquad_casd_df1_inst_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 Biquad cascade filter + * @param[in] S points to an instance of the Q31 Biquad cascade structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_df1_q31( + const arm_biquad_casd_df1_inst_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4. + * @param[in] S points to an instance of the Q31 Biquad cascade structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_df1_fast_q31( + const arm_biquad_casd_df1_inst_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 Biquad cascade filter. + * @param[in,out] S points to an instance of the Q31 Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format + */ + void arm_biquad_cascade_df1_init_q31( + arm_biquad_casd_df1_inst_q31 * S, + uint8_t numStages, + const q31_t * pCoeffs, + q31_t * pState, + int8_t postShift); + + /** + * @brief Processing function for the floating-point Biquad cascade filter. + * @param[in] S points to an instance of the floating-point Biquad cascade structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_df1_f32( + const arm_biquad_casd_df1_inst_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point Biquad cascade filter. + * @param[in,out] S points to an instance of the floating-point Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + */ + void arm_biquad_cascade_df1_init_f32( + arm_biquad_casd_df1_inst_f32 * S, + uint8_t numStages, + const float32_t * pCoeffs, + float32_t * pState); + + /** + * @brief Instance structure for the floating-point matrix structure. + */ + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + float32_t *pData; /**< points to the data of the matrix. */ + } arm_matrix_instance_f32; + + + /** + * @brief Instance structure for the floating-point matrix structure. + */ + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + float64_t *pData; /**< points to the data of the matrix. */ + } arm_matrix_instance_f64; + + /** + * @brief Instance structure for the Q15 matrix structure. + */ + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + q15_t *pData; /**< points to the data of the matrix. */ + } arm_matrix_instance_q15; + + /** + * @brief Instance structure for the Q31 matrix structure. + */ + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + q31_t *pData; /**< points to the data of the matrix. */ + } arm_matrix_instance_q31; + + /** + * @brief Floating-point matrix addition. + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_add_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix addition. + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_add_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix addition. + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_add_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Floating-point, complex, matrix multiplication. + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_cmplx_mult_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15, complex, matrix multiplication. + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_cmplx_mult_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst, + q15_t * pScratch); + + /** + * @brief Q31, complex, matrix multiplication. + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_cmplx_mult_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Floating-point matrix transpose. + * @param[in] pSrc points to the input matrix + * @param[out] pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_trans_f32( + const arm_matrix_instance_f32 * pSrc, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix transpose. + * @param[in] pSrc points to the input matrix + * @param[out] pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_trans_q15( + const arm_matrix_instance_q15 * pSrc, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix transpose. + * @param[in] pSrc points to the input matrix + * @param[out] pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_trans_q31( + const arm_matrix_instance_q31 * pSrc, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Floating-point matrix multiplication + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_mult_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix multiplication + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @param[in] pState points to the array for storing intermediate results + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_mult_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst, + q15_t * pState); + + /** + * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @param[in] pState points to the array for storing intermediate results + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_mult_fast_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst, + q15_t * pState); + + /** + * @brief Q31 matrix multiplication + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_mult_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_mult_fast_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Floating-point matrix subtraction + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_sub_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix subtraction + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_sub_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix subtraction + * @param[in] pSrcA points to the first input matrix structure + * @param[in] pSrcB points to the second input matrix structure + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_sub_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Floating-point matrix scaling. + * @param[in] pSrc points to the input matrix + * @param[in] scale scale factor + * @param[out] pDst points to the output matrix + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_scale_f32( + const arm_matrix_instance_f32 * pSrc, + float32_t scale, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix scaling. + * @param[in] pSrc points to input matrix + * @param[in] scaleFract fractional portion of the scale factor + * @param[in] shift number of bits to shift the result by + * @param[out] pDst points to output matrix + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_scale_q15( + const arm_matrix_instance_q15 * pSrc, + q15_t scaleFract, + int32_t shift, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix scaling. + * @param[in] pSrc points to input matrix + * @param[in] scaleFract fractional portion of the scale factor + * @param[in] shift number of bits to shift the result by + * @param[out] pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ +arm_status arm_mat_scale_q31( + const arm_matrix_instance_q31 * pSrc, + q31_t scaleFract, + int32_t shift, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Q31 matrix initialization. + * @param[in,out] S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] pData points to the matrix data array. + */ +void arm_mat_init_q31( + arm_matrix_instance_q31 * S, + uint16_t nRows, + uint16_t nColumns, + q31_t * pData); + + /** + * @brief Q15 matrix initialization. + * @param[in,out] S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] pData points to the matrix data array. + */ +void arm_mat_init_q15( + arm_matrix_instance_q15 * S, + uint16_t nRows, + uint16_t nColumns, + q15_t * pData); + + /** + * @brief Floating-point matrix initialization. + * @param[in,out] S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] pData points to the matrix data array. + */ +void arm_mat_init_f32( + arm_matrix_instance_f32 * S, + uint16_t nRows, + uint16_t nColumns, + float32_t * pData); + + + /** + * @brief Instance structure for the Q15 PID Control. + */ + typedef struct + { + q15_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ +#if !defined (ARM_MATH_DSP) + q15_t A1; + q15_t A2; +#else + q31_t A1; /**< The derived gain A1 = -Kp - 2Kd | Kd.*/ +#endif + q15_t state[3]; /**< The state array of length 3. */ + q15_t Kp; /**< The proportional gain. */ + q15_t Ki; /**< The integral gain. */ + q15_t Kd; /**< The derivative gain. */ + } arm_pid_instance_q15; + + /** + * @brief Instance structure for the Q31 PID Control. + */ + typedef struct + { + q31_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ + q31_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ + q31_t A2; /**< The derived gain, A2 = Kd . */ + q31_t state[3]; /**< The state array of length 3. */ + q31_t Kp; /**< The proportional gain. */ + q31_t Ki; /**< The integral gain. */ + q31_t Kd; /**< The derivative gain. */ + } arm_pid_instance_q31; + + /** + * @brief Instance structure for the floating-point PID Control. + */ + typedef struct + { + float32_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ + float32_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ + float32_t A2; /**< The derived gain, A2 = Kd . */ + float32_t state[3]; /**< The state array of length 3. */ + float32_t Kp; /**< The proportional gain. */ + float32_t Ki; /**< The integral gain. */ + float32_t Kd; /**< The derivative gain. */ + } arm_pid_instance_f32; + + + + /** + * @brief Initialization function for the floating-point PID Control. + * @param[in,out] S points to an instance of the PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + */ + void arm_pid_init_f32( + arm_pid_instance_f32 * S, + int32_t resetStateFlag); + + + /** + * @brief Reset function for the floating-point PID Control. + * @param[in,out] S is an instance of the floating-point PID Control structure + */ + void arm_pid_reset_f32( + arm_pid_instance_f32 * S); + + + /** + * @brief Initialization function for the Q31 PID Control. + * @param[in,out] S points to an instance of the Q15 PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + */ + void arm_pid_init_q31( + arm_pid_instance_q31 * S, + int32_t resetStateFlag); + + + /** + * @brief Reset function for the Q31 PID Control. + * @param[in,out] S points to an instance of the Q31 PID Control structure + */ + + void arm_pid_reset_q31( + arm_pid_instance_q31 * S); + + + /** + * @brief Initialization function for the Q15 PID Control. + * @param[in,out] S points to an instance of the Q15 PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + */ + void arm_pid_init_q15( + arm_pid_instance_q15 * S, + int32_t resetStateFlag); + + + /** + * @brief Reset function for the Q15 PID Control. + * @param[in,out] S points to an instance of the q15 PID Control structure + */ + void arm_pid_reset_q15( + arm_pid_instance_q15 * S); + + + /** + * @brief Instance structure for the floating-point Linear Interpolate function. + */ + typedef struct + { + uint32_t nValues; /**< nValues */ + float32_t x1; /**< x1 */ + float32_t xSpacing; /**< xSpacing */ + float32_t *pYData; /**< pointer to the table of Y values */ + } arm_linear_interp_instance_f32; + + /** + * @brief Instance structure for the floating-point bilinear interpolation function. + */ + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + float32_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_f32; + + /** + * @brief Instance structure for the Q31 bilinear interpolation function. + */ + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q31_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q31; + + /** + * @brief Instance structure for the Q15 bilinear interpolation function. + */ + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q15_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q15; + + /** + * @brief Instance structure for the Q15 bilinear interpolation function. + */ + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q7_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q7; + + + /** + * @brief Q7 vector multiplication. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_mult_q7( + const q7_t * pSrcA, + const q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q15 vector multiplication. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_mult_q15( + const q15_t * pSrcA, + const q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q31 vector multiplication. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_mult_q31( + const q31_t * pSrcA, + const q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Floating-point vector multiplication. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_mult_f32( + const float32_t * pSrcA, + const float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q15 CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + const q15_t *pTwiddle; /**< points to the Sin twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix2_instance_q15; + +/* Deprecated */ + arm_status arm_cfft_radix2_init_q15( + arm_cfft_radix2_instance_q15 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix2_q15( + const arm_cfft_radix2_instance_q15 * S, + q15_t * pSrc); + + + /** + * @brief Instance structure for the Q15 CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + const q15_t *pTwiddle; /**< points to the twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix4_instance_q15; + +/* Deprecated */ + arm_status arm_cfft_radix4_init_q15( + arm_cfft_radix4_instance_q15 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix4_q15( + const arm_cfft_radix4_instance_q15 * S, + q15_t * pSrc); + + /** + * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + const q31_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix2_instance_q31; + +/* Deprecated */ + arm_status arm_cfft_radix2_init_q31( + arm_cfft_radix2_instance_q31 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix2_q31( + const arm_cfft_radix2_instance_q31 * S, + q31_t * pSrc); + + /** + * @brief Instance structure for the Q31 CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + const q31_t *pTwiddle; /**< points to the twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix4_instance_q31; + +/* Deprecated */ + void arm_cfft_radix4_q31( + const arm_cfft_radix4_instance_q31 * S, + q31_t * pSrc); + +/* Deprecated */ + arm_status arm_cfft_radix4_init_q31( + arm_cfft_radix4_instance_q31 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + const float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + float32_t onebyfftLen; /**< value of 1/fftLen. */ + } arm_cfft_radix2_instance_f32; + +/* Deprecated */ + arm_status arm_cfft_radix2_init_f32( + arm_cfft_radix2_instance_f32 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix2_f32( + const arm_cfft_radix2_instance_f32 * S, + float32_t * pSrc); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + const float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + float32_t onebyfftLen; /**< value of 1/fftLen. */ + } arm_cfft_radix4_instance_f32; + +/* Deprecated */ + arm_status arm_cfft_radix4_init_f32( + arm_cfft_radix4_instance_f32 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix4_f32( + const arm_cfft_radix4_instance_f32 * S, + float32_t * pSrc); + + /** + * @brief Instance structure for the fixed-point CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + const q15_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t bitRevLength; /**< bit reversal table length. */ + } arm_cfft_instance_q15; + +void arm_cfft_q15( + const arm_cfft_instance_q15 * S, + q15_t * p1, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the fixed-point CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + const q31_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t bitRevLength; /**< bit reversal table length. */ + } arm_cfft_instance_q31; + +void arm_cfft_q31( + const arm_cfft_instance_q31 * S, + q31_t * p1, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + const float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t bitRevLength; /**< bit reversal table length. */ + } arm_cfft_instance_f32; + + void arm_cfft_f32( + const arm_cfft_instance_f32 * S, + float32_t * p1, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the Q15 RFFT/RIFFT function. + */ + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + const q15_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + const q15_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + const arm_cfft_instance_q15 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_q15; + + arm_status arm_rfft_init_q15( + arm_rfft_instance_q15 * S, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_q15( + const arm_rfft_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst); + + /** + * @brief Instance structure for the Q31 RFFT/RIFFT function. + */ + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + const q31_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + const q31_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + const arm_cfft_instance_q31 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_q31; + + arm_status arm_rfft_init_q31( + arm_rfft_instance_q31 * S, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_q31( + const arm_rfft_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst); + + /** + * @brief Instance structure for the floating-point RFFT/RIFFT function. + */ + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint16_t fftLenBy2; /**< length of the complex FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + const float32_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + const float32_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_f32; + + arm_status arm_rfft_init_f32( + arm_rfft_instance_f32 * S, + arm_cfft_radix4_instance_f32 * S_CFFT, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_f32( + const arm_rfft_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst); + + /** + * @brief Instance structure for the floating-point RFFT/RIFFT function. + */ +typedef struct + { + arm_cfft_instance_f32 Sint; /**< Internal CFFT structure. */ + uint16_t fftLenRFFT; /**< length of the real sequence */ + const float32_t * pTwiddleRFFT; /**< Twiddle factors real stage */ + } arm_rfft_fast_instance_f32 ; + +arm_status arm_rfft_fast_init_f32 ( + arm_rfft_fast_instance_f32 * S, + uint16_t fftLen); + +arm_status arm_rfft_32_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + +arm_status arm_rfft_64_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + +arm_status arm_rfft_128_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + +arm_status arm_rfft_256_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + +arm_status arm_rfft_512_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + +arm_status arm_rfft_1024_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + +arm_status arm_rfft_2048_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + +arm_status arm_rfft_4096_fast_init_f32 ( arm_rfft_fast_instance_f32 * S ); + + + void arm_rfft_fast_f32( + arm_rfft_fast_instance_f32 * S, + float32_t * p, float32_t * pOut, + uint8_t ifftFlag); + + /** + * @brief Instance structure for the floating-point DCT4/IDCT4 function. + */ + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + float32_t normalize; /**< normalizing factor. */ + const float32_t *pTwiddle; /**< points to the twiddle factor table. */ + const float32_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_f32 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_f32; + + + /** + * @brief Initialization function for the floating-point DCT4/IDCT4. + * @param[in,out] S points to an instance of floating-point DCT4/IDCT4 structure. + * @param[in] S_RFFT points to an instance of floating-point RFFT/RIFFT structure. + * @param[in] S_CFFT points to an instance of floating-point CFFT/CIFFT structure. + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if fftLenReal is not a supported transform length. + */ + arm_status arm_dct4_init_f32( + arm_dct4_instance_f32 * S, + arm_rfft_instance_f32 * S_RFFT, + arm_cfft_radix4_instance_f32 * S_CFFT, + uint16_t N, + uint16_t Nby2, + float32_t normalize); + + + /** + * @brief Processing function for the floating-point DCT4/IDCT4. + * @param[in] S points to an instance of the floating-point DCT4/IDCT4 structure. + * @param[in] pState points to state buffer. + * @param[in,out] pInlineBuffer points to the in-place input and output buffer. + */ + void arm_dct4_f32( + const arm_dct4_instance_f32 * S, + float32_t * pState, + float32_t * pInlineBuffer); + + + /** + * @brief Instance structure for the Q31 DCT4/IDCT4 function. + */ + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + q31_t normalize; /**< normalizing factor. */ + const q31_t *pTwiddle; /**< points to the twiddle factor table. */ + const q31_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_q31 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_q31; + + + /** + * @brief Initialization function for the Q31 DCT4/IDCT4. + * @param[in,out] S points to an instance of Q31 DCT4/IDCT4 structure. + * @param[in] S_RFFT points to an instance of Q31 RFFT/RIFFT structure + * @param[in] S_CFFT points to an instance of Q31 CFFT/CIFFT structure + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if N is not a supported transform length. + */ + arm_status arm_dct4_init_q31( + arm_dct4_instance_q31 * S, + arm_rfft_instance_q31 * S_RFFT, + arm_cfft_radix4_instance_q31 * S_CFFT, + uint16_t N, + uint16_t Nby2, + q31_t normalize); + + + /** + * @brief Processing function for the Q31 DCT4/IDCT4. + * @param[in] S points to an instance of the Q31 DCT4 structure. + * @param[in] pState points to state buffer. + * @param[in,out] pInlineBuffer points to the in-place input and output buffer. + */ + void arm_dct4_q31( + const arm_dct4_instance_q31 * S, + q31_t * pState, + q31_t * pInlineBuffer); + + + /** + * @brief Instance structure for the Q15 DCT4/IDCT4 function. + */ + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + q15_t normalize; /**< normalizing factor. */ + const q15_t *pTwiddle; /**< points to the twiddle factor table. */ + const q15_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_q15 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_q15; + + + /** + * @brief Initialization function for the Q15 DCT4/IDCT4. + * @param[in,out] S points to an instance of Q15 DCT4/IDCT4 structure. + * @param[in] S_RFFT points to an instance of Q15 RFFT/RIFFT structure. + * @param[in] S_CFFT points to an instance of Q15 CFFT/CIFFT structure. + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if N is not a supported transform length. + */ + arm_status arm_dct4_init_q15( + arm_dct4_instance_q15 * S, + arm_rfft_instance_q15 * S_RFFT, + arm_cfft_radix4_instance_q15 * S_CFFT, + uint16_t N, + uint16_t Nby2, + q15_t normalize); + + + /** + * @brief Processing function for the Q15 DCT4/IDCT4. + * @param[in] S points to an instance of the Q15 DCT4 structure. + * @param[in] pState points to state buffer. + * @param[in,out] pInlineBuffer points to the in-place input and output buffer. + */ + void arm_dct4_q15( + const arm_dct4_instance_q15 * S, + q15_t * pState, + q15_t * pInlineBuffer); + + + /** + * @brief Floating-point vector addition. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_add_f32( + const float32_t * pSrcA, + const float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q7 vector addition. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_add_q7( + const q7_t * pSrcA, + const q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q15 vector addition. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_add_q15( + const q15_t * pSrcA, + const q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q31 vector addition. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_add_q31( + const q31_t * pSrcA, + const q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Floating-point vector subtraction. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_sub_f32( + const float32_t * pSrcA, + const float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q7 vector subtraction. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_sub_q7( + const q7_t * pSrcA, + const q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q15 vector subtraction. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_sub_q15( + const q15_t * pSrcA, + const q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q31 vector subtraction. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in each vector + */ + void arm_sub_q31( + const q31_t * pSrcA, + const q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Multiplies a floating-point vector by a scalar. + * @param[in] pSrc points to the input vector + * @param[in] scale scale factor to be applied + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_scale_f32( + const float32_t * pSrc, + float32_t scale, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Multiplies a Q7 vector by a scalar. + * @param[in] pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_scale_q7( + const q7_t * pSrc, + q7_t scaleFract, + int8_t shift, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Multiplies a Q15 vector by a scalar. + * @param[in] pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_scale_q15( + const q15_t * pSrc, + q15_t scaleFract, + int8_t shift, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Multiplies a Q31 vector by a scalar. + * @param[in] pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_scale_q31( + const q31_t * pSrc, + q31_t scaleFract, + int8_t shift, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q7 vector absolute value. + * @param[in] pSrc points to the input buffer + * @param[out] pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + */ + void arm_abs_q7( + const q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Floating-point vector absolute value. + * @param[in] pSrc points to the input buffer + * @param[out] pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + */ + void arm_abs_f32( + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q15 vector absolute value. + * @param[in] pSrc points to the input buffer + * @param[out] pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + */ + void arm_abs_q15( + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Q31 vector absolute value. + * @param[in] pSrc points to the input buffer + * @param[out] pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + */ + void arm_abs_q31( + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Dot product of floating-point vectors. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] result output result returned here + */ + void arm_dot_prod_f32( + const float32_t * pSrcA, + const float32_t * pSrcB, + uint32_t blockSize, + float32_t * result); + + + /** + * @brief Dot product of Q7 vectors. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] result output result returned here + */ + void arm_dot_prod_q7( + const q7_t * pSrcA, + const q7_t * pSrcB, + uint32_t blockSize, + q31_t * result); + + + /** + * @brief Dot product of Q15 vectors. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] result output result returned here + */ + void arm_dot_prod_q15( + const q15_t * pSrcA, + const q15_t * pSrcB, + uint32_t blockSize, + q63_t * result); + + + /** + * @brief Dot product of Q31 vectors. + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] result output result returned here + */ + void arm_dot_prod_q31( + const q31_t * pSrcA, + const q31_t * pSrcB, + uint32_t blockSize, + q63_t * result); + + + /** + * @brief Shifts the elements of a Q7 vector a specified number of bits. + * @param[in] pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_shift_q7( + const q7_t * pSrc, + int8_t shiftBits, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Shifts the elements of a Q15 vector a specified number of bits. + * @param[in] pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_shift_q15( + const q15_t * pSrc, + int8_t shiftBits, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Shifts the elements of a Q31 vector a specified number of bits. + * @param[in] pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_shift_q31( + const q31_t * pSrc, + int8_t shiftBits, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Adds a constant offset to a floating-point vector. + * @param[in] pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_offset_f32( + const float32_t * pSrc, + float32_t offset, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Adds a constant offset to a Q7 vector. + * @param[in] pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_offset_q7( + const q7_t * pSrc, + q7_t offset, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Adds a constant offset to a Q15 vector. + * @param[in] pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_offset_q15( + const q15_t * pSrc, + q15_t offset, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Adds a constant offset to a Q31 vector. + * @param[in] pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_offset_q31( + const q31_t * pSrc, + q31_t offset, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Negates the elements of a floating-point vector. + * @param[in] pSrc points to the input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_negate_f32( + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Negates the elements of a Q7 vector. + * @param[in] pSrc points to the input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_negate_q7( + const q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Negates the elements of a Q15 vector. + * @param[in] pSrc points to the input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_negate_q15( + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Negates the elements of a Q31 vector. + * @param[in] pSrc points to the input vector + * @param[out] pDst points to the output vector + * @param[in] blockSize number of samples in the vector + */ + void arm_negate_q31( + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Copies the elements of a floating-point vector. + * @param[in] pSrc input pointer + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_copy_f32( + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Copies the elements of a Q7 vector. + * @param[in] pSrc input pointer + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_copy_q7( + const q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Copies the elements of a Q15 vector. + * @param[in] pSrc input pointer + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_copy_q15( + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Copies the elements of a Q31 vector. + * @param[in] pSrc input pointer + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_copy_q31( + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Fills a constant value into a floating-point vector. + * @param[in] value input value to be filled + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_fill_f32( + float32_t value, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Fills a constant value into a Q7 vector. + * @param[in] value input value to be filled + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_fill_q7( + q7_t value, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Fills a constant value into a Q15 vector. + * @param[in] value input value to be filled + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_fill_q15( + q15_t value, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Fills a constant value into a Q31 vector. + * @param[in] value input value to be filled + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_fill_q31( + q31_t value, + q31_t * pDst, + uint32_t blockSize); + + +/** + * @brief Convolution of floating-point sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the location where the output result is written. Length srcALen+srcBLen-1. + */ + void arm_conv_f32( + const float32_t * pSrcA, + uint32_t srcALen, + const float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst); + + + /** + * @brief Convolution of Q15 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + */ + void arm_conv_opt_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Convolution of Q15 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the location where the output result is written. Length srcALen+srcBLen-1. + */ + void arm_conv_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + + /** + * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1. + */ + void arm_conv_fast_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + + /** + * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + */ + void arm_conv_fast_opt_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Convolution of Q31 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1. + */ + void arm_conv_q31( + const q31_t * pSrcA, + uint32_t srcALen, + const q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + + /** + * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1. + */ + void arm_conv_fast_q31( + const q31_t * pSrcA, + uint32_t srcALen, + const q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + + /** + * @brief Convolution of Q7 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + */ + void arm_conv_opt_q7( + const q7_t * pSrcA, + uint32_t srcALen, + const q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Convolution of Q7 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1. + */ + void arm_conv_q7( + const q7_t * pSrcA, + uint32_t srcALen, + const q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst); + + + /** + * @brief Partial convolution of floating-point sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_f32( + const float32_t * pSrcA, + uint32_t srcALen, + const float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q15 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_opt_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Partial convolution of Q15 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_fast_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_fast_opt_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Partial convolution of Q31 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_q31( + const q31_t * pSrcA, + uint32_t srcALen, + const q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_fast_q31( + const q31_t * pSrcA, + uint32_t srcALen, + const q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q7 sequences + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_opt_q7( + const q7_t * pSrcA, + uint32_t srcALen, + const q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Partial convolution of Q7 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + arm_status arm_conv_partial_q7( + const q7_t * pSrcA, + uint32_t srcALen, + const q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Instance structure for the Q15 FIR decimator. + */ + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + } arm_fir_decimate_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR decimator. + */ + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + } arm_fir_decimate_instance_q31; + +/** + @brief Instance structure for floating-point FIR decimator. + */ +typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + } arm_fir_decimate_instance_f32; + + +/** + @brief Processing function for floating-point FIR decimator. + @param[in] S points to an instance of the floating-point FIR decimator structure + @param[in] pSrc points to the block of input data + @param[out] pDst points to the block of output data + @param[in] blockSize number of samples to process + */ +void arm_fir_decimate_f32( + const arm_fir_decimate_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + +/** + @brief Initialization function for the floating-point FIR decimator. + @param[in,out] S points to an instance of the floating-point FIR decimator structure + @param[in] numTaps number of coefficients in the filter + @param[in] M decimation factor + @param[in] pCoeffs points to the filter coefficients + @param[in] pState points to the state buffer + @param[in] blockSize number of input samples to process per call + @return execution status + - \ref ARM_MATH_SUCCESS : Operation successful + - \ref ARM_MATH_LENGTH_ERROR : blockSize is not a multiple of M + */ +arm_status arm_fir_decimate_init_f32( + arm_fir_decimate_instance_f32 * S, + uint16_t numTaps, + uint8_t M, + const float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 FIR decimator. + * @param[in] S points to an instance of the Q15 FIR decimator structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_decimate_q15( + const arm_fir_decimate_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. + * @param[in] S points to an instance of the Q15 FIR decimator structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_decimate_fast_q15( + const arm_fir_decimate_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q15 FIR decimator. + * @param[in,out] S points to an instance of the Q15 FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + arm_status arm_fir_decimate_init_q15( + arm_fir_decimate_instance_q15 * S, + uint16_t numTaps, + uint8_t M, + const q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 FIR decimator. + * @param[in] S points to an instance of the Q31 FIR decimator structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_decimate_q31( + const arm_fir_decimate_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. + * @param[in] S points to an instance of the Q31 FIR decimator structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_decimate_fast_q31( + const arm_fir_decimate_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 FIR decimator. + * @param[in,out] S points to an instance of the Q31 FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + arm_status arm_fir_decimate_init_q31( + arm_fir_decimate_instance_q31 * S, + uint16_t numTaps, + uint8_t M, + const q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q15 FIR interpolator. + */ + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + q15_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ + } arm_fir_interpolate_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR interpolator. + */ + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + q31_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ + } arm_fir_interpolate_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR interpolator. + */ + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + float32_t *pState; /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */ + } arm_fir_interpolate_instance_f32; + + + /** + * @brief Processing function for the Q15 FIR interpolator. + * @param[in] S points to an instance of the Q15 FIR interpolator structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_interpolate_q15( + const arm_fir_interpolate_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q15 FIR interpolator. + * @param[in,out] S points to an instance of the Q15 FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] pCoeffs points to the filter coefficient buffer. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + arm_status arm_fir_interpolate_init_q15( + arm_fir_interpolate_instance_q15 * S, + uint8_t L, + uint16_t numTaps, + const q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 FIR interpolator. + * @param[in] S points to an instance of the Q15 FIR interpolator structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_interpolate_q31( + const arm_fir_interpolate_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 FIR interpolator. + * @param[in,out] S points to an instance of the Q31 FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] pCoeffs points to the filter coefficient buffer. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + arm_status arm_fir_interpolate_init_q31( + arm_fir_interpolate_instance_q31 * S, + uint8_t L, + uint16_t numTaps, + const q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the floating-point FIR interpolator. + * @param[in] S points to an instance of the floating-point FIR interpolator structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_interpolate_f32( + const arm_fir_interpolate_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the floating-point FIR interpolator. + * @param[in,out] S points to an instance of the floating-point FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] pCoeffs points to the filter coefficient buffer. + * @param[in] pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + arm_status arm_fir_interpolate_init_f32( + arm_fir_interpolate_instance_f32 * S, + uint8_t L, + uint16_t numTaps, + const float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + + /** + * @brief Instance structure for the high precision Q31 Biquad cascade filter. + */ + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q63_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */ + const q31_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + uint8_t postShift; /**< additional shift, in bits, applied to each output sample. */ + } arm_biquad_cas_df1_32x64_ins_q31; + + + /** + * @param[in] S points to an instance of the high precision Q31 Biquad cascade filter structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cas_df1_32x64_q31( + const arm_biquad_cas_df1_32x64_ins_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @param[in,out] S points to an instance of the high precision Q31 Biquad cascade filter structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] postShift shift to be applied to the output. Varies according to the coefficients format + */ + void arm_biquad_cas_df1_32x64_init_q31( + arm_biquad_cas_df1_32x64_ins_q31 * S, + uint8_t numStages, + const q31_t * pCoeffs, + q63_t * pState, + uint8_t postShift); + + + /** + * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. + */ + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float32_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */ + const float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + } arm_biquad_cascade_df2T_instance_f32; + + /** + * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. + */ + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float32_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */ + const float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + } arm_biquad_cascade_stereo_df2T_instance_f32; + + /** + * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. + */ + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float64_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */ + float64_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + } arm_biquad_cascade_df2T_instance_f64; + + + /** + * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in] S points to an instance of the filter data structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_df2T_f32( + const arm_biquad_cascade_df2T_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 2 channels + * @param[in] S points to an instance of the filter data structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_stereo_df2T_f32( + const arm_biquad_cascade_stereo_df2T_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in] S points to an instance of the filter data structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of samples to process. + */ + void arm_biquad_cascade_df2T_f64( + const arm_biquad_cascade_df2T_instance_f64 * S, + float64_t * pSrc, + float64_t * pDst, + uint32_t blockSize); + + +#if defined(ARM_MATH_NEON) +void arm_biquad_cascade_df2T_compute_coefs_f32( + arm_biquad_cascade_df2T_instance_f32 * S, + uint8_t numStages, + float32_t * pCoeffs); +#endif + /** + * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in,out] S points to an instance of the filter data structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + */ + void arm_biquad_cascade_df2T_init_f32( + arm_biquad_cascade_df2T_instance_f32 * S, + uint8_t numStages, + const float32_t * pCoeffs, + float32_t * pState); + + + /** + * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in,out] S points to an instance of the filter data structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + */ + void arm_biquad_cascade_stereo_df2T_init_f32( + arm_biquad_cascade_stereo_df2T_instance_f32 * S, + uint8_t numStages, + const float32_t * pCoeffs, + float32_t * pState); + + + /** + * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in,out] S points to an instance of the filter data structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] pCoeffs points to the filter coefficients. + * @param[in] pState points to the state buffer. + */ + void arm_biquad_cascade_df2T_init_f64( + arm_biquad_cascade_df2T_instance_f64 * S, + uint8_t numStages, + float64_t * pCoeffs, + float64_t * pState); + + + /** + * @brief Instance structure for the Q15 FIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + q15_t *pState; /**< points to the state variable array. The array is of length numStages. */ + const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + q31_t *pState; /**< points to the state variable array. The array is of length numStages. */ + const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + float32_t *pState; /**< points to the state variable array. The array is of length numStages. */ + const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_f32; + + + /** + * @brief Initialization function for the Q15 FIR lattice filter. + * @param[in] S points to an instance of the Q15 FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] pState points to the state buffer. The array is of length numStages. + */ + void arm_fir_lattice_init_q15( + arm_fir_lattice_instance_q15 * S, + uint16_t numStages, + const q15_t * pCoeffs, + q15_t * pState); + + + /** + * @brief Processing function for the Q15 FIR lattice filter. + * @param[in] S points to an instance of the Q15 FIR lattice structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_fir_lattice_q15( + const arm_fir_lattice_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 FIR lattice filter. + * @param[in] S points to an instance of the Q31 FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] pState points to the state buffer. The array is of length numStages. + */ + void arm_fir_lattice_init_q31( + arm_fir_lattice_instance_q31 * S, + uint16_t numStages, + const q31_t * pCoeffs, + q31_t * pState); + + + /** + * @brief Processing function for the Q31 FIR lattice filter. + * @param[in] S points to an instance of the Q31 FIR lattice structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of samples to process. + */ + void arm_fir_lattice_q31( + const arm_fir_lattice_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + +/** + * @brief Initialization function for the floating-point FIR lattice filter. + * @param[in] S points to an instance of the floating-point FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] pState points to the state buffer. The array is of length numStages. + */ + void arm_fir_lattice_init_f32( + arm_fir_lattice_instance_f32 * S, + uint16_t numStages, + const float32_t * pCoeffs, + float32_t * pState); + + + /** + * @brief Processing function for the floating-point FIR lattice filter. + * @param[in] S points to an instance of the floating-point FIR lattice structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] blockSize number of samples to process. + */ + void arm_fir_lattice_f32( + const arm_fir_lattice_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q15 IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + q15_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + q15_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_q15; + + /** + * @brief Instance structure for the Q31 IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + q31_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + q31_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_q31; + + /** + * @brief Instance structure for the floating-point IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + float32_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + float32_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_f32; + + + /** + * @brief Processing function for the floating-point IIR lattice filter. + * @param[in] S points to an instance of the floating-point IIR lattice structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_iir_lattice_f32( + const arm_iir_lattice_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the floating-point IIR lattice filter. + * @param[in] S points to an instance of the floating-point IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. + * @param[in] pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. + * @param[in] pState points to the state buffer. The array is of length numStages+blockSize-1. + * @param[in] blockSize number of samples to process. + */ + void arm_iir_lattice_init_f32( + arm_iir_lattice_instance_f32 * S, + uint16_t numStages, + float32_t * pkCoeffs, + float32_t * pvCoeffs, + float32_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 IIR lattice filter. + * @param[in] S points to an instance of the Q31 IIR lattice structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_iir_lattice_q31( + const arm_iir_lattice_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 IIR lattice filter. + * @param[in] S points to an instance of the Q31 IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. + * @param[in] pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. + * @param[in] pState points to the state buffer. The array is of length numStages+blockSize. + * @param[in] blockSize number of samples to process. + */ + void arm_iir_lattice_init_q31( + arm_iir_lattice_instance_q31 * S, + uint16_t numStages, + q31_t * pkCoeffs, + q31_t * pvCoeffs, + q31_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 IIR lattice filter. + * @param[in] S points to an instance of the Q15 IIR lattice structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + */ + void arm_iir_lattice_q15( + const arm_iir_lattice_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + +/** + * @brief Initialization function for the Q15 IIR lattice filter. + * @param[in] S points to an instance of the fixed-point Q15 IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] pkCoeffs points to reflection coefficient buffer. The array is of length numStages. + * @param[in] pvCoeffs points to ladder coefficient buffer. The array is of length numStages+1. + * @param[in] pState points to state buffer. The array is of length numStages+blockSize. + * @param[in] blockSize number of samples to process per call. + */ + void arm_iir_lattice_init_q15( + arm_iir_lattice_instance_q15 * S, + uint16_t numStages, + q15_t * pkCoeffs, + q15_t * pvCoeffs, + q15_t * pState, + uint32_t blockSize); + + + /** + * @brief Instance structure for the floating-point LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + float32_t mu; /**< step size that controls filter coefficient updates. */ + } arm_lms_instance_f32; + + + /** + * @brief Processing function for floating-point LMS filter. + * @param[in] S points to an instance of the floating-point LMS filter structure. + * @param[in] pSrc points to the block of input data. + * @param[in] pRef points to the block of reference data. + * @param[out] pOut points to the block of output data. + * @param[out] pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_f32( + const arm_lms_instance_f32 * S, + const float32_t * pSrc, + float32_t * pRef, + float32_t * pOut, + float32_t * pErr, + uint32_t blockSize); + + + /** + * @brief Initialization function for floating-point LMS filter. + * @param[in] S points to an instance of the floating-point LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] pCoeffs points to the coefficient buffer. + * @param[in] pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_init_f32( + arm_lms_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + float32_t mu, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q15 LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q15_t mu; /**< step size that controls filter coefficient updates. */ + uint32_t postShift; /**< bit shift applied to coefficients. */ + } arm_lms_instance_q15; + + + /** + * @brief Initialization function for the Q15 LMS filter. + * @param[in] S points to an instance of the Q15 LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] pCoeffs points to the coefficient buffer. + * @param[in] pState points to the state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + */ + void arm_lms_init_q15( + arm_lms_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + q15_t mu, + uint32_t blockSize, + uint32_t postShift); + + + /** + * @brief Processing function for Q15 LMS filter. + * @param[in] S points to an instance of the Q15 LMS filter structure. + * @param[in] pSrc points to the block of input data. + * @param[in] pRef points to the block of reference data. + * @param[out] pOut points to the block of output data. + * @param[out] pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_q15( + const arm_lms_instance_q15 * S, + const q15_t * pSrc, + q15_t * pRef, + q15_t * pOut, + q15_t * pErr, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q31 LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q31_t mu; /**< step size that controls filter coefficient updates. */ + uint32_t postShift; /**< bit shift applied to coefficients. */ + } arm_lms_instance_q31; + + + /** + * @brief Processing function for Q31 LMS filter. + * @param[in] S points to an instance of the Q15 LMS filter structure. + * @param[in] pSrc points to the block of input data. + * @param[in] pRef points to the block of reference data. + * @param[out] pOut points to the block of output data. + * @param[out] pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_q31( + const arm_lms_instance_q31 * S, + const q31_t * pSrc, + q31_t * pRef, + q31_t * pOut, + q31_t * pErr, + uint32_t blockSize); + + + /** + * @brief Initialization function for Q31 LMS filter. + * @param[in] S points to an instance of the Q31 LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] pCoeffs points to coefficient buffer. + * @param[in] pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + */ + void arm_lms_init_q31( + arm_lms_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + q31_t mu, + uint32_t blockSize, + uint32_t postShift); + + + /** + * @brief Instance structure for the floating-point normalized LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + float32_t mu; /**< step size that control filter coefficient updates. */ + float32_t energy; /**< saves previous frame energy. */ + float32_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_f32; + + + /** + * @brief Processing function for floating-point normalized LMS filter. + * @param[in] S points to an instance of the floating-point normalized LMS filter structure. + * @param[in] pSrc points to the block of input data. + * @param[in] pRef points to the block of reference data. + * @param[out] pOut points to the block of output data. + * @param[out] pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_norm_f32( + arm_lms_norm_instance_f32 * S, + const float32_t * pSrc, + float32_t * pRef, + float32_t * pOut, + float32_t * pErr, + uint32_t blockSize); + + + /** + * @brief Initialization function for floating-point normalized LMS filter. + * @param[in] S points to an instance of the floating-point LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] pCoeffs points to coefficient buffer. + * @param[in] pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_norm_init_f32( + arm_lms_norm_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + float32_t mu, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q31 normalized LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q31_t mu; /**< step size that controls filter coefficient updates. */ + uint8_t postShift; /**< bit shift applied to coefficients. */ + const q31_t *recipTable; /**< points to the reciprocal initial value table. */ + q31_t energy; /**< saves previous frame energy. */ + q31_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_q31; + + + /** + * @brief Processing function for Q31 normalized LMS filter. + * @param[in] S points to an instance of the Q31 normalized LMS filter structure. + * @param[in] pSrc points to the block of input data. + * @param[in] pRef points to the block of reference data. + * @param[out] pOut points to the block of output data. + * @param[out] pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_norm_q31( + arm_lms_norm_instance_q31 * S, + const q31_t * pSrc, + q31_t * pRef, + q31_t * pOut, + q31_t * pErr, + uint32_t blockSize); + + + /** + * @brief Initialization function for Q31 normalized LMS filter. + * @param[in] S points to an instance of the Q31 normalized LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] pCoeffs points to coefficient buffer. + * @param[in] pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + */ + void arm_lms_norm_init_q31( + arm_lms_norm_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + q31_t mu, + uint32_t blockSize, + uint8_t postShift); + + + /** + * @brief Instance structure for the Q15 normalized LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< Number of coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q15_t mu; /**< step size that controls filter coefficient updates. */ + uint8_t postShift; /**< bit shift applied to coefficients. */ + const q15_t *recipTable; /**< Points to the reciprocal initial value table. */ + q15_t energy; /**< saves previous frame energy. */ + q15_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_q15; + + + /** + * @brief Processing function for Q15 normalized LMS filter. + * @param[in] S points to an instance of the Q15 normalized LMS filter structure. + * @param[in] pSrc points to the block of input data. + * @param[in] pRef points to the block of reference data. + * @param[out] pOut points to the block of output data. + * @param[out] pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + */ + void arm_lms_norm_q15( + arm_lms_norm_instance_q15 * S, + const q15_t * pSrc, + q15_t * pRef, + q15_t * pOut, + q15_t * pErr, + uint32_t blockSize); + + + /** + * @brief Initialization function for Q15 normalized LMS filter. + * @param[in] S points to an instance of the Q15 normalized LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] pCoeffs points to coefficient buffer. + * @param[in] pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + */ + void arm_lms_norm_init_q15( + arm_lms_norm_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + q15_t mu, + uint32_t blockSize, + uint8_t postShift); + + + /** + * @brief Correlation of floating-point sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + */ + void arm_correlate_f32( + const float32_t * pSrcA, + uint32_t srcALen, + const float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst); + + +/** + @brief Correlation of Q15 sequences + @param[in] pSrcA points to the first input sequence + @param[in] srcALen length of the first input sequence + @param[in] pSrcB points to the second input sequence + @param[in] srcBLen length of the second input sequence + @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + @param[in] pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. +*/ +void arm_correlate_opt_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch); + + +/** + @brief Correlation of Q15 sequences. + @param[in] pSrcA points to the first input sequence + @param[in] srcALen length of the first input sequence + @param[in] pSrcB points to the second input sequence + @param[in] srcBLen length of the second input sequence + @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + */ + void arm_correlate_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + +/** + @brief Correlation of Q15 sequences (fast version). + @param[in] pSrcA points to the first input sequence + @param[in] srcALen length of the first input sequence + @param[in] pSrcB points to the second input sequence + @param[in] srcBLen length of the second input sequence + @param[out] pDst points to the location where the output result is written. Length 2 * max(srcALen, srcBLen) - 1. + @return none + */ +void arm_correlate_fast_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + +/** + @brief Correlation of Q15 sequences (fast version). + @param[in] pSrcA points to the first input sequence. + @param[in] srcALen length of the first input sequence. + @param[in] pSrcB points to the second input sequence. + @param[in] srcBLen length of the second input sequence. + @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + @param[in] pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + */ +void arm_correlate_fast_opt_q15( + const q15_t * pSrcA, + uint32_t srcALen, + const q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch); + + + /** + * @brief Correlation of Q31 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + */ + void arm_correlate_q31( + const q31_t * pSrcA, + uint32_t srcALen, + const q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + +/** + @brief Correlation of Q31 sequences (fast version). + @param[in] pSrcA points to the first input sequence + @param[in] srcALen length of the first input sequence + @param[in] pSrcB points to the second input sequence + @param[in] srcBLen length of the second input sequence + @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + */ +void arm_correlate_fast_q31( + const q31_t * pSrcA, + uint32_t srcALen, + const q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + + /** + * @brief Correlation of Q7 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + */ + void arm_correlate_opt_q7( + const q7_t * pSrcA, + uint32_t srcALen, + const q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Correlation of Q7 sequences. + * @param[in] pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + */ + void arm_correlate_q7( + const q7_t * pSrcA, + uint32_t srcALen, + const q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst); + + + /** + * @brief Instance structure for the floating-point sparse FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + float32_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_f32; + + /** + * @brief Instance structure for the Q31 sparse FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q31_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q31; + + /** + * @brief Instance structure for the Q15 sparse FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q15_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q15; + + /** + * @brief Instance structure for the Q7 sparse FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q7_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + const q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q7; + + + /** + * @brief Processing function for the floating-point sparse FIR filter. + * @param[in] S points to an instance of the floating-point sparse FIR structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] pScratchIn points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_sparse_f32( + arm_fir_sparse_instance_f32 * S, + const float32_t * pSrc, + float32_t * pDst, + float32_t * pScratchIn, + uint32_t blockSize); + + + /** + * @brief Initialization function for the floating-point sparse FIR filter. + * @param[in,out] S points to an instance of the floating-point sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] pCoeffs points to the array of filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + */ + void arm_fir_sparse_init_f32( + arm_fir_sparse_instance_f32 * S, + uint16_t numTaps, + const float32_t * pCoeffs, + float32_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 sparse FIR filter. + * @param[in] S points to an instance of the Q31 sparse FIR structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] pScratchIn points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_sparse_q31( + arm_fir_sparse_instance_q31 * S, + const q31_t * pSrc, + q31_t * pDst, + q31_t * pScratchIn, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 sparse FIR filter. + * @param[in,out] S points to an instance of the Q31 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] pCoeffs points to the array of filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + */ + void arm_fir_sparse_init_q31( + arm_fir_sparse_instance_q31 * S, + uint16_t numTaps, + const q31_t * pCoeffs, + q31_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 sparse FIR filter. + * @param[in] S points to an instance of the Q15 sparse FIR structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] pScratchIn points to a temporary buffer of size blockSize. + * @param[in] pScratchOut points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_sparse_q15( + arm_fir_sparse_instance_q15 * S, + const q15_t * pSrc, + q15_t * pDst, + q15_t * pScratchIn, + q31_t * pScratchOut, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q15 sparse FIR filter. + * @param[in,out] S points to an instance of the Q15 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] pCoeffs points to the array of filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + */ + void arm_fir_sparse_init_q15( + arm_fir_sparse_instance_q15 * S, + uint16_t numTaps, + const q15_t * pCoeffs, + q15_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q7 sparse FIR filter. + * @param[in] S points to an instance of the Q7 sparse FIR structure. + * @param[in] pSrc points to the block of input data. + * @param[out] pDst points to the block of output data + * @param[in] pScratchIn points to a temporary buffer of size blockSize. + * @param[in] pScratchOut points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + */ + void arm_fir_sparse_q7( + arm_fir_sparse_instance_q7 * S, + const q7_t * pSrc, + q7_t * pDst, + q7_t * pScratchIn, + q31_t * pScratchOut, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q7 sparse FIR filter. + * @param[in,out] S points to an instance of the Q7 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] pCoeffs points to the array of filter coefficients. + * @param[in] pState points to the state buffer. + * @param[in] pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + */ + void arm_fir_sparse_init_q7( + arm_fir_sparse_instance_q7 * S, + uint16_t numTaps, + const q7_t * pCoeffs, + q7_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + + /** + * @brief Floating-point sin_cos function. + * @param[in] theta input value in degrees + * @param[out] pSinVal points to the processed sine output. + * @param[out] pCosVal points to the processed cos output. + */ + void arm_sin_cos_f32( + float32_t theta, + float32_t * pSinVal, + float32_t * pCosVal); + + + /** + * @brief Q31 sin_cos function. + * @param[in] theta scaled input value in degrees + * @param[out] pSinVal points to the processed sine output. + * @param[out] pCosVal points to the processed cosine output. + */ + void arm_sin_cos_q31( + q31_t theta, + q31_t * pSinVal, + q31_t * pCosVal); + + + /** + * @brief Floating-point complex conjugate. + * @param[in] pSrc points to the input vector + * @param[out] pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + */ + void arm_cmplx_conj_f32( + const float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex conjugate. + * @param[in] pSrc points to the input vector + * @param[out] pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + */ + void arm_cmplx_conj_q31( + const q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + + /** + * @brief Q15 complex conjugate. + * @param[in] pSrc points to the input vector + * @param[out] pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + */ + void arm_cmplx_conj_q15( + const q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + + /** + * @brief Floating-point complex magnitude squared + * @param[in] pSrc points to the complex input vector + * @param[out] pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + */ + void arm_cmplx_mag_squared_f32( + const float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + + /** + * @brief Q31 complex magnitude squared + * @param[in] pSrc points to the complex input vector + * @param[out] pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + */ + void arm_cmplx_mag_squared_q31( + const q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + + /** + * @brief Q15 complex magnitude squared + * @param[in] pSrc points to the complex input vector + * @param[out] pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + */ + void arm_cmplx_mag_squared_q15( + const q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + + /** + * @ingroup groupController + */ + + /** + * @defgroup PID PID Motor Control + * + * A Proportional Integral Derivative (PID) controller is a generic feedback control + * loop mechanism widely used in industrial control systems. + * A PID controller is the most commonly used type of feedback controller. + * + * This set of functions implements (PID) controllers + * for Q15, Q31, and floating-point data types. The functions operate on a single sample + * of data and each call to the function returns a single processed value. + * S points to an instance of the PID control data structure. in + * is the input sample value. The functions return the output value. + * + * \par Algorithm: + * 
+   *    y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]
+   *    A0 = Kp + Ki + Kd
+   *    A1 = (-Kp ) - (2 * Kd )
+   *    A2 = Kd
+   *
+ * + * \par + * where \c Kp is proportional constant, \c Ki is Integral constant and \c Kd is Derivative constant + * + * \par + * \image html PID.gif "Proportional Integral Derivative Controller" + * + * \par + * The PID controller calculates an "error" value as the difference between + * the measured output and the reference input. + * The controller attempts to minimize the error by adjusting the process control inputs. + * The proportional value determines the reaction to the current error, + * the integral value determines the reaction based on the sum of recent errors, + * and the derivative value determines the reaction based on the rate at which the error has been changing. + * + * \par Instance Structure + * The Gains A0, A1, A2 and state variables for a PID controller are stored together in an instance data structure. + * A separate instance structure must be defined for each PID Controller. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Reset Functions + * There is also an associated reset function for each data type which clears the state array. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Initializes the Gains A0, A1, A2 from Kp,Ki, Kd gains. + * - Zeros out the values in the state buffer. + * + * \par + * Instance structure cannot be placed into a const data section and it is recommended to use the initialization function. + * + * \par Fixed-Point Behavior + * Care must be taken when using the fixed-point versions of the PID Controller functions. + * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup PID + * @{ + */ + + /** + * @brief Process function for the floating-point PID Control. + * @param[in,out] S is an instance of the floating-point PID Control structure + * @param[in] in input sample to process + * @return processed output sample. + */ + __STATIC_FORCEINLINE float32_t arm_pid_f32( + arm_pid_instance_f32 * S, + float32_t in) + { + float32_t out; + + /* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2] */ + out = (S->A0 * in) + + (S->A1 * S->state[0]) + (S->A2 * S->state[1]) + (S->state[2]); + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + + } + +/** + @brief Process function for the Q31 PID Control. + @param[in,out] S points to an instance of the Q31 PID Control structure + @param[in] in input sample to process + @return processed output sample. + + \par Scaling and Overflow Behavior + The function is implemented using an internal 64-bit accumulator. + The accumulator has a 2.62 format and maintains full precision of the intermediate multiplication results but provides only a single guard bit. + Thus, if the accumulator result overflows it wraps around rather than clip. + In order to avoid overflows completely the input signal must be scaled down by 2 bits as there are four additions. + After all multiply-accumulates are performed, the 2.62 accumulator is truncated to 1.32 format and then saturated to 1.31 format. + */ +__STATIC_FORCEINLINE q31_t arm_pid_q31( + arm_pid_instance_q31 * S, + q31_t in) + { + q63_t acc; + q31_t out; + + /* acc = A0 * x[n] */ + acc = (q63_t) S->A0 * in; + + /* acc += A1 * x[n-1] */ + acc += (q63_t) S->A1 * S->state[0]; + + /* acc += A2 * x[n-2] */ + acc += (q63_t) S->A2 * S->state[1]; + + /* convert output to 1.31 format to add y[n-1] */ + out = (q31_t) (acc >> 31U); + + /* out += y[n-1] */ + out += S->state[2]; + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + } + + +/** + @brief Process function for the Q15 PID Control. + @param[in,out] S points to an instance of the Q15 PID Control structure + @param[in] in input sample to process + @return processed output sample. + + \par Scaling and Overflow Behavior + The function is implemented using a 64-bit internal accumulator. + Both Gains and state variables are represented in 1.15 format and multiplications yield a 2.30 result. + The 2.30 intermediate results are accumulated in a 64-bit accumulator in 34.30 format. + There is no risk of internal overflow with this approach and the full precision of intermediate multiplications is preserved. + After all additions have been performed, the accumulator is truncated to 34.15 format by discarding low 15 bits. + Lastly, the accumulator is saturated to yield a result in 1.15 format. + */ +__STATIC_FORCEINLINE q15_t arm_pid_q15( + arm_pid_instance_q15 * S, + q15_t in) + { + q63_t acc; + q15_t out; + +#if defined (ARM_MATH_DSP) + /* Implementation of PID controller */ + + /* acc = A0 * x[n] */ + acc = (q31_t) __SMUAD((uint32_t)S->A0, (uint32_t)in); + + /* acc += A1 * x[n-1] + A2 * x[n-2] */ + acc = (q63_t)__SMLALD((uint32_t)S->A1, (uint32_t)read_q15x2 (S->state), (uint64_t)acc); +#else + /* acc = A0 * x[n] */ + acc = ((q31_t) S->A0) * in; + + /* acc += A1 * x[n-1] + A2 * x[n-2] */ + acc += (q31_t) S->A1 * S->state[0]; + acc += (q31_t) S->A2 * S->state[1]; +#endif + + /* acc += y[n-1] */ + acc += (q31_t) S->state[2] << 15; + + /* saturate the output */ + out = (q15_t) (__SSAT((acc >> 15), 16)); + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + } + + /** + * @} end of PID group + */ + + + /** + * @brief Floating-point matrix inverse. + * @param[in] src points to the instance of the input floating-point matrix structure. + * @param[out] dst points to the instance of the output floating-point matrix structure. + * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match. + * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR. + */ + arm_status arm_mat_inverse_f32( + const arm_matrix_instance_f32 * src, + arm_matrix_instance_f32 * dst); + + + /** + * @brief Floating-point matrix inverse. + * @param[in] src points to the instance of the input floating-point matrix structure. + * @param[out] dst points to the instance of the output floating-point matrix structure. + * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match. + * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR. + */ + arm_status arm_mat_inverse_f64( + const arm_matrix_instance_f64 * src, + arm_matrix_instance_f64 * dst); + + + + /** + * @ingroup groupController + */ + + /** + * @defgroup clarke Vector Clarke Transform + * Forward Clarke transform converts the instantaneous stator phases into a two-coordinate time invariant vector. + * Generally the Clarke transform uses three-phase currents Ia, Ib and Ic to calculate currents + * in the two-phase orthogonal stator axis Ialpha and Ibeta. + * When Ialpha is superposed with Ia as shown in the figure below + * \image html clarke.gif Stator current space vector and its components in (a,b). + * and Ia + Ib + Ic = 0, in this condition Ialpha and Ibeta + * can be calculated using only Ia and Ib. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html clarkeFormula.gif + * where Ia and Ib are the instantaneous stator phases and + * pIalpha and pIbeta are the two coordinates of time invariant vector. + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Clarke transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup clarke + * @{ + */ + + /** + * + * @brief Floating-point Clarke transform + * @param[in] Ia input three-phase coordinate a + * @param[in] Ib input three-phase coordinate b + * @param[out] pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] pIbeta points to output two-phase orthogonal vector axis beta + * @return none + */ + __STATIC_FORCEINLINE void arm_clarke_f32( + float32_t Ia, + float32_t Ib, + float32_t * pIalpha, + float32_t * pIbeta) + { + /* Calculate pIalpha using the equation, pIalpha = Ia */ + *pIalpha = Ia; + + /* Calculate pIbeta using the equation, pIbeta = (1/sqrt(3)) * Ia + (2/sqrt(3)) * Ib */ + *pIbeta = ((float32_t) 0.57735026919 * Ia + (float32_t) 1.15470053838 * Ib); + } + + +/** + @brief Clarke transform for Q31 version + @param[in] Ia input three-phase coordinate a + @param[in] Ib input three-phase coordinate b + @param[out] pIalpha points to output two-phase orthogonal vector axis alpha + @param[out] pIbeta points to output two-phase orthogonal vector axis beta + @return none + + \par Scaling and Overflow Behavior + The function is implemented using an internal 32-bit accumulator. + The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + There is saturation on the addition, hence there is no risk of overflow. + */ +__STATIC_FORCEINLINE void arm_clarke_q31( + q31_t Ia, + q31_t Ib, + q31_t * pIalpha, + q31_t * pIbeta) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + + /* Calculating pIalpha from Ia by equation pIalpha = Ia */ + *pIalpha = Ia; + + /* Intermediate product is calculated by (1/(sqrt(3)) * Ia) */ + product1 = (q31_t) (((q63_t) Ia * 0x24F34E8B) >> 30); + + /* Intermediate product is calculated by (2/sqrt(3) * Ib) */ + product2 = (q31_t) (((q63_t) Ib * 0x49E69D16) >> 30); + + /* pIbeta is calculated by adding the intermediate products */ + *pIbeta = __QADD(product1, product2); + } + + /** + * @} end of clarke group + */ + + + /** + * @ingroup groupController + */ + + /** + * @defgroup inv_clarke Vector Inverse Clarke Transform + * Inverse Clarke transform converts the two-coordinate time invariant vector into instantaneous stator phases. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html clarkeInvFormula.gif + * where pIa and pIb are the instantaneous stator phases and + * Ialpha and Ibeta are the two coordinates of time invariant vector. + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Clarke transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup inv_clarke + * @{ + */ + + /** + * @brief Floating-point Inverse Clarke transform + * @param[in] Ialpha input two-phase orthogonal vector axis alpha + * @param[in] Ibeta input two-phase orthogonal vector axis beta + * @param[out] pIa points to output three-phase coordinate a + * @param[out] pIb points to output three-phase coordinate b + * @return none + */ + __STATIC_FORCEINLINE void arm_inv_clarke_f32( + float32_t Ialpha, + float32_t Ibeta, + float32_t * pIa, + float32_t * pIb) + { + /* Calculating pIa from Ialpha by equation pIa = Ialpha */ + *pIa = Ialpha; + + /* Calculating pIb from Ialpha and Ibeta by equation pIb = -(1/2) * Ialpha + (sqrt(3)/2) * Ibeta */ + *pIb = -0.5f * Ialpha + 0.8660254039f * Ibeta; + } + + +/** + @brief Inverse Clarke transform for Q31 version + @param[in] Ialpha input two-phase orthogonal vector axis alpha + @param[in] Ibeta input two-phase orthogonal vector axis beta + @param[out] pIa points to output three-phase coordinate a + @param[out] pIb points to output three-phase coordinate b + @return none + + \par Scaling and Overflow Behavior + The function is implemented using an internal 32-bit accumulator. + The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + There is saturation on the subtraction, hence there is no risk of overflow. + */ +__STATIC_FORCEINLINE void arm_inv_clarke_q31( + q31_t Ialpha, + q31_t Ibeta, + q31_t * pIa, + q31_t * pIb) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + + /* Calculating pIa from Ialpha by equation pIa = Ialpha */ + *pIa = Ialpha; + + /* Intermediate product is calculated by (1/(2*sqrt(3)) * Ia) */ + product1 = (q31_t) (((q63_t) (Ialpha) * (0x40000000)) >> 31); + + /* Intermediate product is calculated by (1/sqrt(3) * pIb) */ + product2 = (q31_t) (((q63_t) (Ibeta) * (0x6ED9EBA1)) >> 31); + + /* pIb is calculated by subtracting the products */ + *pIb = __QSUB(product2, product1); + } + + /** + * @} end of inv_clarke group + */ + + + + /** + * @ingroup groupController + */ + + /** + * @defgroup park Vector Park Transform + * + * Forward Park transform converts the input two-coordinate vector to flux and torque components. + * The Park transform can be used to realize the transformation of the Ialpha and the Ibeta currents + * from the stationary to the moving reference frame and control the spatial relationship between + * the stator vector current and rotor flux vector. + * If we consider the d axis aligned with the rotor flux, the diagram below shows the + * current vector and the relationship from the two reference frames: + * \image html park.gif "Stator current space vector and its component in (a,b) and in the d,q rotating reference frame" + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html parkFormula.gif + * where Ialpha and Ibeta are the stator vector components, + * pId and pIq are rotor vector components and cosVal and sinVal are the + * cosine and sine values of theta (rotor flux position). + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Park transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup park + * @{ + */ + + /** + * @brief Floating-point Park transform + * @param[in] Ialpha input two-phase vector coordinate alpha + * @param[in] Ibeta input two-phase vector coordinate beta + * @param[out] pId points to output rotor reference frame d + * @param[out] pIq points to output rotor reference frame q + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none + * + * The function implements the forward Park transform. + * + */ + __STATIC_FORCEINLINE void arm_park_f32( + float32_t Ialpha, + float32_t Ibeta, + float32_t * pId, + float32_t * pIq, + float32_t sinVal, + float32_t cosVal) + { + /* Calculate pId using the equation, pId = Ialpha * cosVal + Ibeta * sinVal */ + *pId = Ialpha * cosVal + Ibeta * sinVal; + + /* Calculate pIq using the equation, pIq = - Ialpha * sinVal + Ibeta * cosVal */ + *pIq = -Ialpha * sinVal + Ibeta * cosVal; + } + + +/** + @brief Park transform for Q31 version + @param[in] Ialpha input two-phase vector coordinate alpha + @param[in] Ibeta input two-phase vector coordinate beta + @param[out] pId points to output rotor reference frame d + @param[out] pIq points to output rotor reference frame q + @param[in] sinVal sine value of rotation angle theta + @param[in] cosVal cosine value of rotation angle theta + @return none + + \par Scaling and Overflow Behavior + The function is implemented using an internal 32-bit accumulator. + The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + There is saturation on the addition and subtraction, hence there is no risk of overflow. + */ +__STATIC_FORCEINLINE void arm_park_q31( + q31_t Ialpha, + q31_t Ibeta, + q31_t * pId, + q31_t * pIq, + q31_t sinVal, + q31_t cosVal) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + q31_t product3, product4; /* Temporary variables used to store intermediate results */ + + /* Intermediate product is calculated by (Ialpha * cosVal) */ + product1 = (q31_t) (((q63_t) (Ialpha) * (cosVal)) >> 31); + + /* Intermediate product is calculated by (Ibeta * sinVal) */ + product2 = (q31_t) (((q63_t) (Ibeta) * (sinVal)) >> 31); + + + /* Intermediate product is calculated by (Ialpha * sinVal) */ + product3 = (q31_t) (((q63_t) (Ialpha) * (sinVal)) >> 31); + + /* Intermediate product is calculated by (Ibeta * cosVal) */ + product4 = (q31_t) (((q63_t) (Ibeta) * (cosVal)) >> 31); + + /* Calculate pId by adding the two intermediate products 1 and 2 */ + *pId = __QADD(product1, product2); + + /* Calculate pIq by subtracting the two intermediate products 3 from 4 */ + *pIq = __QSUB(product4, product3); + } + + /** + * @} end of park group + */ + + + /** + * @ingroup groupController + */ + + /** + * @defgroup inv_park Vector Inverse Park transform + * Inverse Park transform converts the input flux and torque components to two-coordinate vector. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html parkInvFormula.gif + * where pIalpha and pIbeta are the stator vector components, + * Id and Iq are rotor vector components and cosVal and sinVal are the + * cosine and sine values of theta (rotor flux position). + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Park transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup inv_park + * @{ + */ + + /** + * @brief Floating-point Inverse Park transform + * @param[in] Id input coordinate of rotor reference frame d + * @param[in] Iq input coordinate of rotor reference frame q + * @param[out] pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] pIbeta points to output two-phase orthogonal vector axis beta + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none + */ + __STATIC_FORCEINLINE void arm_inv_park_f32( + float32_t Id, + float32_t Iq, + float32_t * pIalpha, + float32_t * pIbeta, + float32_t sinVal, + float32_t cosVal) + { + /* Calculate pIalpha using the equation, pIalpha = Id * cosVal - Iq * sinVal */ + *pIalpha = Id * cosVal - Iq * sinVal; + + /* Calculate pIbeta using the equation, pIbeta = Id * sinVal + Iq * cosVal */ + *pIbeta = Id * sinVal + Iq * cosVal; + } + + +/** + @brief Inverse Park transform for Q31 version + @param[in] Id input coordinate of rotor reference frame d + @param[in] Iq input coordinate of rotor reference frame q + @param[out] pIalpha points to output two-phase orthogonal vector axis alpha + @param[out] pIbeta points to output two-phase orthogonal vector axis beta + @param[in] sinVal sine value of rotation angle theta + @param[in] cosVal cosine value of rotation angle theta + @return none + + @par Scaling and Overflow Behavior + The function is implemented using an internal 32-bit accumulator. + The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + There is saturation on the addition, hence there is no risk of overflow. + */ +__STATIC_FORCEINLINE void arm_inv_park_q31( + q31_t Id, + q31_t Iq, + q31_t * pIalpha, + q31_t * pIbeta, + q31_t sinVal, + q31_t cosVal) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + q31_t product3, product4; /* Temporary variables used to store intermediate results */ + + /* Intermediate product is calculated by (Id * cosVal) */ + product1 = (q31_t) (((q63_t) (Id) * (cosVal)) >> 31); + + /* Intermediate product is calculated by (Iq * sinVal) */ + product2 = (q31_t) (((q63_t) (Iq) * (sinVal)) >> 31); + + + /* Intermediate product is calculated by (Id * sinVal) */ + product3 = (q31_t) (((q63_t) (Id) * (sinVal)) >> 31); + + /* Intermediate product is calculated by (Iq * cosVal) */ + product4 = (q31_t) (((q63_t) (Iq) * (cosVal)) >> 31); + + /* Calculate pIalpha by using the two intermediate products 1 and 2 */ + *pIalpha = __QSUB(product1, product2); + + /* Calculate pIbeta by using the two intermediate products 3 and 4 */ + *pIbeta = __QADD(product4, product3); + } + + /** + * @} end of Inverse park group + */ + + + /** + * @ingroup groupInterpolation + */ + + /** + * @defgroup LinearInterpolate Linear Interpolation + * + * Linear interpolation is a method of curve fitting using linear polynomials. + * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line + * + * \par + * \image html LinearInterp.gif "Linear interpolation" + * + * \par + * A Linear Interpolate function calculates an output value(y), for the input(x) + * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values) + * + * \par Algorithm: + * 
+   *       y = y0 + (x - x0) * ((y1 - y0)/(x1-x0))
+   *       where x0, x1 are nearest values of input x
+   *             y0, y1 are nearest values to output y
+   *
+ * + * \par + * This set of functions implements Linear interpolation process + * for Q7, Q15, Q31, and floating-point data types. The functions operate on a single + * sample of data and each call to the function returns a single processed value. + * S points to an instance of the Linear Interpolate function data structure. + * x is the input sample value. The functions returns the output value. + * + * \par + * if x is outside of the table boundary, Linear interpolation returns first value of the table + * if x is below input range and returns last value of table if x is above range. + */ + + /** + * @addtogroup LinearInterpolate + * @{ + */ + + /** + * @brief Process function for the floating-point Linear Interpolation Function. + * @param[in,out] S is an instance of the floating-point Linear Interpolation structure + * @param[in] x input sample to process + * @return y processed output sample. + * + */ + __STATIC_FORCEINLINE float32_t arm_linear_interp_f32( + arm_linear_interp_instance_f32 * S, + float32_t x) + { + float32_t y; + float32_t x0, x1; /* Nearest input values */ + float32_t y0, y1; /* Nearest output values */ + float32_t xSpacing = S->xSpacing; /* spacing between input values */ + int32_t i; /* Index variable */ + float32_t *pYData = S->pYData; /* pointer to output table */ + + /* Calculation of index */ + i = (int32_t) ((x - S->x1) / xSpacing); + + if (i < 0) + { + /* Iniatilize output for below specified range as least output value of table */ + y = pYData[0]; + } + else if ((uint32_t)i >= S->nValues) + { + /* Iniatilize output for above specified range as last output value of table */ + y = pYData[S->nValues - 1]; + } + else + { + /* Calculation of nearest input values */ + x0 = S->x1 + i * xSpacing; + x1 = S->x1 + (i + 1) * xSpacing; + + /* Read of nearest output values */ + y0 = pYData[i]; + y1 = pYData[i + 1]; + + /* Calculation of output */ + y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0)); + + } + + /* returns output value */ + return (y); + } + + + /** + * + * @brief Process function for the Q31 Linear Interpolation Function. + * @param[in] pYData pointer to Q31 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + * + */ + __STATIC_FORCEINLINE q31_t arm_linear_interp_q31( + q31_t * pYData, + q31_t x, + uint32_t nValues) + { + q31_t y; /* output */ + q31_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + int32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + index = ((x & (q31_t)0xFFF00000) >> 20); + + if (index >= (int32_t)(nValues - 1)) + { + return (pYData[nValues - 1]); + } + else if (index < 0) + { + return (pYData[0]); + } + else + { + /* 20 bits for the fractional part */ + /* shift left by 11 to keep fract in 1.31 format */ + fract = (x & 0x000FFFFF) << 11; + + /* Read two nearest output values from the index in 1.31(q31) format */ + y0 = pYData[index]; + y1 = pYData[index + 1]; + + /* Calculation of y0 * (1-fract) and y is in 2.30 format */ + y = ((q31_t) ((q63_t) y0 * (0x7FFFFFFF - fract) >> 32)); + + /* Calculation of y0 * (1-fract) + y1 *fract and y is in 2.30 format */ + y += ((q31_t) (((q63_t) y1 * fract) >> 32)); + + /* Convert y to 1.31 format */ + return (y << 1U); + } + } + + + /** + * + * @brief Process function for the Q15 Linear Interpolation Function. + * @param[in] pYData pointer to Q15 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + * + */ + __STATIC_FORCEINLINE q15_t arm_linear_interp_q15( + q15_t * pYData, + q31_t x, + uint32_t nValues) + { + q63_t y; /* output */ + q15_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + int32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + index = ((x & (int32_t)0xFFF00000) >> 20); + + if (index >= (int32_t)(nValues - 1)) + { + return (pYData[nValues - 1]); + } + else if (index < 0) + { + return (pYData[0]); + } + else + { + /* 20 bits for the fractional part */ + /* fract is in 12.20 format */ + fract = (x & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y0 = pYData[index]; + y1 = pYData[index + 1]; + + /* Calculation of y0 * (1-fract) and y is in 13.35 format */ + y = ((q63_t) y0 * (0xFFFFF - fract)); + + /* Calculation of (y0 * (1-fract) + y1 * fract) and y is in 13.35 format */ + y += ((q63_t) y1 * (fract)); + + /* convert y to 1.15 format */ + return (q15_t) (y >> 20); + } + } + + + /** + * + * @brief Process function for the Q7 Linear Interpolation Function. + * @param[in] pYData pointer to Q7 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + */ + __STATIC_FORCEINLINE q7_t arm_linear_interp_q7( + q7_t * pYData, + q31_t x, + uint32_t nValues) + { + q31_t y; /* output */ + q7_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + uint32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + if (x < 0) + { + return (pYData[0]); + } + index = (x >> 20) & 0xfff; + + if (index >= (nValues - 1)) + { + return (pYData[nValues - 1]); + } + else + { + /* 20 bits for the fractional part */ + /* fract is in 12.20 format */ + fract = (x & 0x000FFFFF); + + /* Read two nearest output values from the index and are in 1.7(q7) format */ + y0 = pYData[index]; + y1 = pYData[index + 1]; + + /* Calculation of y0 * (1-fract ) and y is in 13.27(q27) format */ + y = ((y0 * (0xFFFFF - fract))); + + /* Calculation of y1 * fract + y0 * (1-fract) and y is in 13.27(q27) format */ + y += (y1 * fract); + + /* convert y to 1.7(q7) format */ + return (q7_t) (y >> 20); + } + } + + /** + * @} end of LinearInterpolate group + */ + + /** + * @brief Fast approximation to the trigonometric sine function for floating-point data. + * @param[in] x input value in radians. + * @return sin(x). + */ + float32_t arm_sin_f32( + float32_t x); + + + /** + * @brief Fast approximation to the trigonometric sine function for Q31 data. + * @param[in] x Scaled input value in radians. + * @return sin(x). + */ + q31_t arm_sin_q31( + q31_t x); + + + /** + * @brief Fast approximation to the trigonometric sine function for Q15 data. + * @param[in] x Scaled input value in radians. + * @return sin(x). + */ + q15_t arm_sin_q15( + q15_t x); + + + /** + * @brief Fast approximation to the trigonometric cosine function for floating-point data. + * @param[in] x input value in radians. + * @return cos(x). + */ + float32_t arm_cos_f32( + float32_t x); + + + /** + * @brief Fast approximation to the trigonometric cosine function for Q31 data. + * @param[in] x Scaled input value in radians. + * @return cos(x). + */ + q31_t arm_cos_q31( + q31_t x); + + + /** + * @brief Fast approximation to the trigonometric cosine function for Q15 data. + * @param[in] x Scaled input value in radians. + * @return cos(x). + */ + q15_t arm_cos_q15( + q15_t x); + + + /** + * @ingroup groupFastMath + */ + + + /** + * @defgroup SQRT Square Root + * + * Computes the square root of a number. + * There are separate functions for Q15, Q31, and floating-point data types. + * The square root function is computed using the Newton-Raphson algorithm. + * This is an iterative algorithm of the form: + * 
+   *      x1 = x0 - f(x0)/f'(x0)
+   *
+ * where x1 is the current estimate, + * x0 is the previous estimate, and + * f'(x0) is the derivative of f() evaluated at x0. + * For the square root function, the algorithm reduces to: + * 
+   *     x0 = in/2                         [initial guess]
+   *     x1 = 1/2 * ( x0 + in / x0)        [each iteration]
+   *
+ */ + + + /** + * @addtogroup SQRT + * @{ + */ + +/** + @brief Floating-point square root function. + @param[in] in input value + @param[out] pOut square root of input value + @return execution status + - \ref ARM_MATH_SUCCESS : input value is positive + - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0 + */ +__STATIC_FORCEINLINE arm_status arm_sqrt_f32( + float32_t in, + float32_t * pOut) + { + if (in >= 0.0f) + { +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + *pOut = __sqrtf(in); + #else + *pOut = sqrtf(in); + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + __ASM("VSQRT.F32 %0,%1" : "=t"(*pOut) : "t"(in)); + #else + *pOut = sqrtf(in); + #endif + +#else + *pOut = sqrtf(in); +#endif + + return (ARM_MATH_SUCCESS); + } + else + { + *pOut = 0.0f; + return (ARM_MATH_ARGUMENT_ERROR); + } + } + + +/** + @brief Q31 square root function. + @param[in] in input value. The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF + @param[out] pOut points to square root of input value + @return execution status + - \ref ARM_MATH_SUCCESS : input value is positive + - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0 + */ +arm_status arm_sqrt_q31( + q31_t in, + q31_t * pOut); + + +/** + @brief Q15 square root function. + @param[in] in input value. The range of the input value is [0 +1) or 0x0000 to 0x7FFF + @param[out] pOut points to square root of input value + @return execution status + - \ref ARM_MATH_SUCCESS : input value is positive + - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0 + */ +arm_status arm_sqrt_q15( + q15_t in, + q15_t * pOut); + + /** + * @brief Vector Floating-point square root function. + * @param[in] pIn input vector. + * @param[out] pOut vector of square roots of input elements. + * @param[in] len length of input vector. + * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if + * in is negative value and returns zero output for negative values. + */ + void arm_vsqrt_f32( + float32_t * pIn, + float32_t * pOut, + uint16_t len); + + void arm_vsqrt_q31( + q31_t * pIn, + q31_t * pOut, + uint16_t len); + + void arm_vsqrt_q15( + q15_t * pIn, + q15_t * pOut, + uint16_t len); + + /** + * @} end of SQRT group + */ + + + /** + * @brief floating-point Circular write function. + */ + __STATIC_FORCEINLINE void arm_circularWrite_f32( + int32_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const int32_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0U; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while (i > 0U) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if (wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = (uint16_t)wOffset; + } + + + + /** + * @brief floating-point Circular Read function. + */ + __STATIC_FORCEINLINE void arm_circularRead_f32( + int32_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + int32_t * dst, + int32_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0U; + int32_t rOffset; + int32_t* dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + dst_end = dst_base + dst_length; + + /* Loop over the blockSize */ + i = blockSize; + + while (i > 0U) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if (dst == dst_end) + { + dst = dst_base; + } + + /* Circularly update rOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if (rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + + /** + * @brief Q15 Circular write function. + */ + __STATIC_FORCEINLINE void arm_circularWrite_q15( + q15_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const q15_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0U; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while (i > 0U) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if (wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = (uint16_t)wOffset; + } + + + /** + * @brief Q15 Circular Read function. + */ + __STATIC_FORCEINLINE void arm_circularRead_q15( + q15_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + q15_t * dst, + q15_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0; + int32_t rOffset; + q15_t* dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + + dst_end = dst_base + dst_length; + + /* Loop over the blockSize */ + i = blockSize; + + while (i > 0U) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if (dst == dst_end) + { + dst = dst_base; + } + + /* Circularly update wOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if (rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + + /** + * @brief Q7 Circular write function. + */ + __STATIC_FORCEINLINE void arm_circularWrite_q7( + q7_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const q7_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0U; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while (i > 0U) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if (wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = (uint16_t)wOffset; + } + + + /** + * @brief Q7 Circular Read function. + */ + __STATIC_FORCEINLINE void arm_circularRead_q7( + q7_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + q7_t * dst, + q7_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0; + int32_t rOffset; + q7_t* dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + + dst_end = dst_base + dst_length; + + /* Loop over the blockSize */ + i = blockSize; + + while (i > 0U) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if (dst == dst_end) + { + dst = dst_base; + } + + /* Circularly update rOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if (rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + + /** + * @brief Sum of the squares of the elements of a Q31 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_power_q31( + const q31_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + + /** + * @brief Sum of the squares of the elements of a floating-point vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_power_f32( + const float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + + /** + * @brief Sum of the squares of the elements of a Q15 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_power_q15( + const q15_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + + /** + * @brief Sum of the squares of the elements of a Q7 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_power_q7( + const q7_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + + /** + * @brief Mean value of a Q7 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_mean_q7( + const q7_t * pSrc, + uint32_t blockSize, + q7_t * pResult); + + + /** + * @brief Mean value of a Q15 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_mean_q15( + const q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + + /** + * @brief Mean value of a Q31 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_mean_q31( + const q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + + /** + * @brief Mean value of a floating-point vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_mean_f32( + const float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + + /** + * @brief Variance of the elements of a floating-point vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_var_f32( + const float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + + /** + * @brief Variance of the elements of a Q31 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_var_q31( + const q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + + /** + * @brief Variance of the elements of a Q15 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_var_q15( + const q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + + /** + * @brief Root Mean Square of the elements of a floating-point vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_rms_f32( + const float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + + /** + * @brief Root Mean Square of the elements of a Q31 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_rms_q31( + const q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + + /** + * @brief Root Mean Square of the elements of a Q15 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_rms_q15( + const q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + + /** + * @brief Standard deviation of the elements of a floating-point vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_std_f32( + const float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + + /** + * @brief Standard deviation of the elements of a Q31 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_std_q31( + const q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + + /** + * @brief Standard deviation of the elements of a Q15 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output value. + */ + void arm_std_q15( + const q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + + /** + * @brief Floating-point complex magnitude + * @param[in] pSrc points to the complex input vector + * @param[out] pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + */ + void arm_cmplx_mag_f32( + const float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + + /** + * @brief Q31 complex magnitude + * @param[in] pSrc points to the complex input vector + * @param[out] pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + */ + void arm_cmplx_mag_q31( + const q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + + /** + * @brief Q15 complex magnitude + * @param[in] pSrc points to the complex input vector + * @param[out] pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + */ + void arm_cmplx_mag_q15( + const q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + + /** + * @brief Q15 complex dot product + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] realResult real part of the result returned here + * @param[out] imagResult imaginary part of the result returned here + */ + void arm_cmplx_dot_prod_q15( + const q15_t * pSrcA, + const q15_t * pSrcB, + uint32_t numSamples, + q31_t * realResult, + q31_t * imagResult); + + + /** + * @brief Q31 complex dot product + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] realResult real part of the result returned here + * @param[out] imagResult imaginary part of the result returned here + */ + void arm_cmplx_dot_prod_q31( + const q31_t * pSrcA, + const q31_t * pSrcB, + uint32_t numSamples, + q63_t * realResult, + q63_t * imagResult); + + + /** + * @brief Floating-point complex dot product + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] realResult real part of the result returned here + * @param[out] imagResult imaginary part of the result returned here + */ + void arm_cmplx_dot_prod_f32( + const float32_t * pSrcA, + const float32_t * pSrcB, + uint32_t numSamples, + float32_t * realResult, + float32_t * imagResult); + + + /** + * @brief Q15 complex-by-real multiplication + * @param[in] pSrcCmplx points to the complex input vector + * @param[in] pSrcReal points to the real input vector + * @param[out] pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + */ + void arm_cmplx_mult_real_q15( + const q15_t * pSrcCmplx, + const q15_t * pSrcReal, + q15_t * pCmplxDst, + uint32_t numSamples); + + + /** + * @brief Q31 complex-by-real multiplication + * @param[in] pSrcCmplx points to the complex input vector + * @param[in] pSrcReal points to the real input vector + * @param[out] pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + */ + void arm_cmplx_mult_real_q31( + const q31_t * pSrcCmplx, + const q31_t * pSrcReal, + q31_t * pCmplxDst, + uint32_t numSamples); + + + /** + * @brief Floating-point complex-by-real multiplication + * @param[in] pSrcCmplx points to the complex input vector + * @param[in] pSrcReal points to the real input vector + * @param[out] pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + */ + void arm_cmplx_mult_real_f32( + const float32_t * pSrcCmplx, + const float32_t * pSrcReal, + float32_t * pCmplxDst, + uint32_t numSamples); + + + /** + * @brief Minimum value of a Q7 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] result is output pointer + * @param[in] index is the array index of the minimum value in the input buffer. + */ + void arm_min_q7( + const q7_t * pSrc, + uint32_t blockSize, + q7_t * result, + uint32_t * index); + + + /** + * @brief Minimum value of a Q15 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output pointer + * @param[in] pIndex is the array index of the minimum value in the input buffer. + */ + void arm_min_q15( + const q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult, + uint32_t * pIndex); + + + /** + * @brief Minimum value of a Q31 vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output pointer + * @param[out] pIndex is the array index of the minimum value in the input buffer. + */ + void arm_min_q31( + const q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult, + uint32_t * pIndex); + + + /** + * @brief Minimum value of a floating-point vector. + * @param[in] pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] pResult is output pointer + * @param[out] pIndex is the array index of the minimum value in the input buffer. + */ + void arm_min_f32( + const float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult, + uint32_t * pIndex); + + +/** + * @brief Maximum value of a Q7 vector. + * @param[in] pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] pResult maximum value returned here + * @param[out] pIndex index of maximum value returned here + */ + void arm_max_q7( + const q7_t * pSrc, + uint32_t blockSize, + q7_t * pResult, + uint32_t * pIndex); + + +/** + * @brief Maximum value of a Q15 vector. + * @param[in] pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] pResult maximum value returned here + * @param[out] pIndex index of maximum value returned here + */ + void arm_max_q15( + const q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult, + uint32_t * pIndex); + + +/** + * @brief Maximum value of a Q31 vector. + * @param[in] pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] pResult maximum value returned here + * @param[out] pIndex index of maximum value returned here + */ + void arm_max_q31( + const q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult, + uint32_t * pIndex); + + +/** + * @brief Maximum value of a floating-point vector. + * @param[in] pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] pResult maximum value returned here + * @param[out] pIndex index of maximum value returned here + */ + void arm_max_f32( + const float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult, + uint32_t * pIndex); + + + /** + * @brief Q15 complex-by-complex multiplication + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + */ + void arm_cmplx_mult_cmplx_q15( + const q15_t * pSrcA, + const q15_t * pSrcB, + q15_t * pDst, + uint32_t numSamples); + + + /** + * @brief Q31 complex-by-complex multiplication + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + */ + void arm_cmplx_mult_cmplx_q31( + const q31_t * pSrcA, + const q31_t * pSrcB, + q31_t * pDst, + uint32_t numSamples); + + + /** + * @brief Floating-point complex-by-complex multiplication + * @param[in] pSrcA points to the first input vector + * @param[in] pSrcB points to the second input vector + * @param[out] pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + */ + void arm_cmplx_mult_cmplx_f32( + const float32_t * pSrcA, + const float32_t * pSrcB, + float32_t * pDst, + uint32_t numSamples); + + + /** + * @brief Converts the elements of the floating-point vector to Q31 vector. + * @param[in] pSrc points to the floating-point input vector + * @param[out] pDst points to the Q31 output vector + * @param[in] blockSize length of the input vector + */ + void arm_float_to_q31( + const float32_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the floating-point vector to Q15 vector. + * @param[in] pSrc points to the floating-point input vector + * @param[out] pDst points to the Q15 output vector + * @param[in] blockSize length of the input vector + */ + void arm_float_to_q15( + const float32_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the floating-point vector to Q7 vector. + * @param[in] pSrc points to the floating-point input vector + * @param[out] pDst points to the Q7 output vector + * @param[in] blockSize length of the input vector + */ + void arm_float_to_q7( + const float32_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q31 vector to floating-point vector. + * @param[in] pSrc is input pointer + * @param[out] pDst is output pointer + * @param[in] blockSize is the number of samples to process + */ + void arm_q31_to_float( + const q31_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q31 vector to Q15 vector. + * @param[in] pSrc is input pointer + * @param[out] pDst is output pointer + * @param[in] blockSize is the number of samples to process + */ + void arm_q31_to_q15( + const q31_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q31 vector to Q7 vector. + * @param[in] pSrc is input pointer + * @param[out] pDst is output pointer + * @param[in] blockSize is the number of samples to process + */ + void arm_q31_to_q7( + const q31_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q15 vector to floating-point vector. + * @param[in] pSrc is input pointer + * @param[out] pDst is output pointer + * @param[in] blockSize is the number of samples to process + */ + void arm_q15_to_float( + const q15_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q15 vector to Q31 vector. + * @param[in] pSrc is input pointer + * @param[out] pDst is output pointer + * @param[in] blockSize is the number of samples to process + */ + void arm_q15_to_q31( + const q15_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q15 vector to Q7 vector. + * @param[in] pSrc is input pointer + * @param[out] pDst is output pointer + * @param[in] blockSize is the number of samples to process + */ + void arm_q15_to_q7( + const q15_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q7 vector to floating-point vector. + * @param[in] pSrc is input pointer + * @param[out] pDst is output pointer + * @param[in] blockSize is the number of samples to process + */ + void arm_q7_to_float( + const q7_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q7 vector to Q31 vector. + * @param[in] pSrc input pointer + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_q7_to_q31( + const q7_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q7 vector to Q15 vector. + * @param[in] pSrc input pointer + * @param[out] pDst output pointer + * @param[in] blockSize number of samples to process + */ + void arm_q7_to_q15( + const q7_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @ingroup groupInterpolation + */ + + /** + * @defgroup BilinearInterpolate Bilinear Interpolation + * + * Bilinear interpolation is an extension of linear interpolation applied to a two dimensional grid. + * The underlying function f(x, y) is sampled on a regular grid and the interpolation process + * determines values between the grid points. + * Bilinear interpolation is equivalent to two step linear interpolation, first in the x-dimension and then in the y-dimension. + * Bilinear interpolation is often used in image processing to rescale images. + * The CMSIS DSP library provides bilinear interpolation functions for Q7, Q15, Q31, and floating-point data types. + * + * Algorithm + * \par + * The instance structure used by the bilinear interpolation functions describes a two dimensional data table. + * For floating-point, the instance structure is defined as: + * 
+   *   typedef struct
+   *   {
+   *     uint16_t numRows;
+   *     uint16_t numCols;
+   *     float32_t *pData;
+   * } arm_bilinear_interp_instance_f32;
+   *
+ * + * \par + * where numRows specifies the number of rows in the table; + * numCols specifies the number of columns in the table; + * and pData points to an array of size numRows*numCols values. + * The data table pTable is organized in row order and the supplied data values fall on integer indexes. + * That is, table element (x,y) is located at pTable[x + y*numCols] where x and y are integers. + * + * \par + * Let (x, y) specify the desired interpolation point. Then define: + * 
+   *     XF = floor(x)
+   *     YF = floor(y)
+   *
+ * \par + * The interpolated output point is computed as: + * 
+   *  f(x, y) = f(XF, YF) * (1-(x-XF)) * (1-(y-YF))
+   *           + f(XF+1, YF) * (x-XF)*(1-(y-YF))
+   *           + f(XF, YF+1) * (1-(x-XF))*(y-YF)
+   *           + f(XF+1, YF+1) * (x-XF)*(y-YF)
+   *
+ * Note that the coordinates (x, y) contain integer and fractional components. + * The integer components specify which portion of the table to use while the + * fractional components control the interpolation processor. + * + * \par + * if (x,y) are outside of the table boundary, Bilinear interpolation returns zero output. + */ + + + /** + * @addtogroup BilinearInterpolate + * @{ + */ + + /** + * @brief Floating-point bilinear interpolation. + * @param[in,out] S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate. + * @param[in] Y interpolation coordinate. + * @return out interpolated value. + */ + __STATIC_FORCEINLINE float32_t arm_bilinear_interp_f32( + const arm_bilinear_interp_instance_f32 * S, + float32_t X, + float32_t Y) + { + float32_t out; + float32_t f00, f01, f10, f11; + float32_t *pData = S->pData; + int32_t xIndex, yIndex, index; + float32_t xdiff, ydiff; + float32_t b1, b2, b3, b4; + + xIndex = (int32_t) X; + yIndex = (int32_t) Y; + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if (xIndex < 0 || xIndex > (S->numRows - 1) || yIndex < 0 || yIndex > (S->numCols - 1)) + { + return (0); + } + + /* Calculation of index for two nearest points in X-direction */ + index = (xIndex - 1) + (yIndex - 1) * S->numCols; + + + /* Read two nearest points in X-direction */ + f00 = pData[index]; + f01 = pData[index + 1]; + + /* Calculation of index for two nearest points in Y-direction */ + index = (xIndex - 1) + (yIndex) * S->numCols; + + + /* Read two nearest points in Y-direction */ + f10 = pData[index]; + f11 = pData[index + 1]; + + /* Calculation of intermediate values */ + b1 = f00; + b2 = f01 - f00; + b3 = f10 - f00; + b4 = f00 - f01 - f10 + f11; + + /* Calculation of fractional part in X */ + xdiff = X - xIndex; + + /* Calculation of fractional part in Y */ + ydiff = Y - yIndex; + + /* Calculation of bi-linear interpolated output */ + out = b1 + b2 * xdiff + b3 * ydiff + b4 * xdiff * ydiff; + + /* return to application */ + return (out); + } + + + /** + * @brief Q31 bilinear interpolation. + * @param[in,out] S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + __STATIC_FORCEINLINE q31_t arm_bilinear_interp_q31( + arm_bilinear_interp_instance_q31 * S, + q31_t X, + q31_t Y) + { + q31_t out; /* Temporary output */ + q31_t acc = 0; /* output */ + q31_t xfract, yfract; /* X, Y fractional parts */ + q31_t x1, x2, y1, y2; /* Nearest output values */ + int32_t rI, cI; /* Row and column indices */ + q31_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & (q31_t)0xFFF00000) >> 20); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & (q31_t)0xFFF00000) >> 20); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if (rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* shift left xfract by 11 to keep 1.31 format */ + xfract = (X & 0x000FFFFF) << 11U; + + /* Read two nearest output values from the index */ + x1 = pYData[(rI) + (int32_t)nCols * (cI) ]; + x2 = pYData[(rI) + (int32_t)nCols * (cI) + 1]; + + /* 20 bits for the fractional part */ + /* shift left yfract by 11 to keep 1.31 format */ + yfract = (Y & 0x000FFFFF) << 11U; + + /* Read two nearest output values from the index */ + y1 = pYData[(rI) + (int32_t)nCols * (cI + 1) ]; + y2 = pYData[(rI) + (int32_t)nCols * (cI + 1) + 1]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 3.29(q29) format */ + out = ((q31_t) (((q63_t) x1 * (0x7FFFFFFF - xfract)) >> 32)); + acc = ((q31_t) (((q63_t) out * (0x7FFFFFFF - yfract)) >> 32)); + + /* x2 * (xfract) * (1-yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) x2 * (0x7FFFFFFF - yfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (xfract) >> 32)); + + /* y1 * (1 - xfract) * (yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) y1 * (0x7FFFFFFF - xfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); + + /* y2 * (xfract) * (yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) y2 * (xfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); + + /* Convert acc to 1.31(q31) format */ + return ((q31_t)(acc << 2)); + } + + + /** + * @brief Q15 bilinear interpolation. + * @param[in,out] S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + __STATIC_FORCEINLINE q15_t arm_bilinear_interp_q15( + arm_bilinear_interp_instance_q15 * S, + q31_t X, + q31_t Y) + { + q63_t acc = 0; /* output */ + q31_t out; /* Temporary output */ + q15_t x1, x2, y1, y2; /* Nearest output values */ + q31_t xfract, yfract; /* X, Y fractional parts */ + int32_t rI, cI; /* Row and column indices */ + q15_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & (q31_t)0xFFF00000) >> 20); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & (q31_t)0xFFF00000) >> 20); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if (rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* xfract should be in 12.20 format */ + xfract = (X & 0x000FFFFF); + + /* Read two nearest output values from the index */ + x1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) ]; + x2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) + 1]; + + /* 20 bits for the fractional part */ + /* yfract should be in 12.20 format */ + yfract = (Y & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) ]; + y2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) + 1]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 13.51 format */ + + /* x1 is in 1.15(q15), xfract in 12.20 format and out is in 13.35 format */ + /* convert 13.35 to 13.31 by right shifting and out is in 1.31 */ + out = (q31_t) (((q63_t) x1 * (0xFFFFF - xfract)) >> 4U); + acc = ((q63_t) out * (0xFFFFF - yfract)); + + /* x2 * (xfract) * (1-yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) x2 * (0xFFFFF - yfract)) >> 4U); + acc += ((q63_t) out * (xfract)); + + /* y1 * (1 - xfract) * (yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) y1 * (0xFFFFF - xfract)) >> 4U); + acc += ((q63_t) out * (yfract)); + + /* y2 * (xfract) * (yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) y2 * (xfract)) >> 4U); + acc += ((q63_t) out * (yfract)); + + /* acc is in 13.51 format and down shift acc by 36 times */ + /* Convert out to 1.15 format */ + return ((q15_t)(acc >> 36)); + } + + + /** + * @brief Q7 bilinear interpolation. + * @param[in,out] S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + __STATIC_FORCEINLINE q7_t arm_bilinear_interp_q7( + arm_bilinear_interp_instance_q7 * S, + q31_t X, + q31_t Y) + { + q63_t acc = 0; /* output */ + q31_t out; /* Temporary output */ + q31_t xfract, yfract; /* X, Y fractional parts */ + q7_t x1, x2, y1, y2; /* Nearest output values */ + int32_t rI, cI; /* Row and column indices */ + q7_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & (q31_t)0xFFF00000) >> 20); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & (q31_t)0xFFF00000) >> 20); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if (rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* xfract should be in 12.20 format */ + xfract = (X & (q31_t)0x000FFFFF); + + /* Read two nearest output values from the index */ + x1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) ]; + x2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) + 1]; + + /* 20 bits for the fractional part */ + /* yfract should be in 12.20 format */ + yfract = (Y & (q31_t)0x000FFFFF); + + /* Read two nearest output values from the index */ + y1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) ]; + y2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) + 1]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 16.47 format */ + out = ((x1 * (0xFFFFF - xfract))); + acc = (((q63_t) out * (0xFFFFF - yfract))); + + /* x2 * (xfract) * (1-yfract) in 2.22 and adding to acc */ + out = ((x2 * (0xFFFFF - yfract))); + acc += (((q63_t) out * (xfract))); + + /* y1 * (1 - xfract) * (yfract) in 2.22 and adding to acc */ + out = ((y1 * (0xFFFFF - xfract))); + acc += (((q63_t) out * (yfract))); + + /* y2 * (xfract) * (yfract) in 2.22 and adding to acc */ + out = ((y2 * (yfract))); + acc += (((q63_t) out * (xfract))); + + /* acc in 16.47 format and down shift by 40 to convert to 1.7 format */ + return ((q7_t)(acc >> 40)); + } + + /** + * @} end of BilinearInterpolate group + */ + + +/* SMMLAR */ +#define multAcc_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32) + +/* SMMLSR */ +#define multSub_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32) + +/* SMMULR */ +#define mult_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32) + +/* SMMLA */ +#define multAcc_32x32_keep32(a, x, y) \ + a += (q31_t) (((q63_t) x * y) >> 32) + +/* SMMLS */ +#define multSub_32x32_keep32(a, x, y) \ + a -= (q31_t) (((q63_t) x * y) >> 32) + +/* SMMUL */ +#define mult_32x32_keep32(a, x, y) \ + a = (q31_t) (((q63_t) x * y ) >> 32) + + +#if defined ( __CC_ARM ) + /* Enter low optimization region - place directly above function definition */ + #if defined( __ARM_ARCH_7EM__ ) + #define LOW_OPTIMIZATION_ENTER \ + _Pragma ("push") \ + _Pragma ("O1") + #else + #define LOW_OPTIMIZATION_ENTER + #endif + + /* Exit low optimization region - place directly after end of function definition */ + #if defined ( __ARM_ARCH_7EM__ ) + #define LOW_OPTIMIZATION_EXIT \ + _Pragma ("pop") + #else + #define LOW_OPTIMIZATION_EXIT + #endif + + /* Enter low optimization region - place directly above function definition */ + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + + /* Exit low optimization region - place directly after end of function definition */ + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined (__ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 ) + #define LOW_OPTIMIZATION_ENTER + #define LOW_OPTIMIZATION_EXIT + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined ( __GNUC__ ) + #define LOW_OPTIMIZATION_ENTER \ + __attribute__(( optimize("-O1") )) + #define LOW_OPTIMIZATION_EXIT + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined ( __ICCARM__ ) + /* Enter low optimization region - place directly above function definition */ + #if defined ( __ARM_ARCH_7EM__ ) + #define LOW_OPTIMIZATION_ENTER \ + _Pragma ("optimize=low") + #else + #define LOW_OPTIMIZATION_ENTER + #endif + + /* Exit low optimization region - place directly after end of function definition */ + #define LOW_OPTIMIZATION_EXIT + + /* Enter low optimization region - place directly above function definition */ + #if defined ( __ARM_ARCH_7EM__ ) + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER \ + _Pragma ("optimize=low") + #else + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + #endif + + /* Exit low optimization region - place directly after end of function definition */ + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined ( __TI_ARM__ ) + #define LOW_OPTIMIZATION_ENTER + #define LOW_OPTIMIZATION_EXIT + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined ( __CSMC__ ) + #define LOW_OPTIMIZATION_ENTER + #define LOW_OPTIMIZATION_EXIT + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined ( __TASKING__ ) + #define LOW_OPTIMIZATION_ENTER + #define LOW_OPTIMIZATION_EXIT + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#endif + + +#ifdef __cplusplus +} +#endif + +/* Compiler specific diagnostic adjustment */ +#if defined ( __CC_ARM ) + +#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 ) + +#elif defined ( __GNUC__ ) +#pragma GCC diagnostic pop + +#elif defined ( __ICCARM__ ) + +#elif defined ( __TI_ARM__ ) + +#elif defined ( __CSMC__ ) + +#elif defined ( __TASKING__ ) + +#elif defined ( _MSC_VER ) + +#else + #error Unknown compiler +#endif + +#endif /* _ARM_MATH_H */ + +/** + * + * End of file. + */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armcc.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armcc.h new file mode 100644 index 0000000000..59f173ac71 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armcc.h @@ -0,0 +1,894 @@ +/**************************************************************************//** + * @file cmsis_armcc.h + * @brief CMSIS compiler ARMCC (Arm Compiler 5) header file + * @version V5.1.0 + * @date 08. May 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CMSIS_ARMCC_H +#define __CMSIS_ARMCC_H + + +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 400677) + #error "Please use Arm Compiler Toolchain V4.0.677 or later!" +#endif + +/* CMSIS compiler control architecture macros */ +#if ((defined (__TARGET_ARCH_6_M ) && (__TARGET_ARCH_6_M == 1)) || \ + (defined (__TARGET_ARCH_6S_M ) && (__TARGET_ARCH_6S_M == 1)) ) + #define __ARM_ARCH_6M__ 1 +#endif + +#if (defined (__TARGET_ARCH_7_M ) && (__TARGET_ARCH_7_M == 1)) + #define __ARM_ARCH_7M__ 1 +#endif + +#if (defined (__TARGET_ARCH_7E_M) && (__TARGET_ARCH_7E_M == 1)) + #define __ARM_ARCH_7EM__ 1 +#endif + + /* __ARM_ARCH_8M_BASE__ not applicable */ + /* __ARM_ARCH_8M_MAIN__ not applicable */ + +/* CMSIS compiler control DSP macros */ +#if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) + #define __ARM_FEATURE_DSP 1 +#endif + +/* CMSIS compiler specific defines */ +#ifndef __ASM + #define __ASM __asm +#endif +#ifndef __INLINE + #define __INLINE __inline +#endif +#ifndef __STATIC_INLINE + #define __STATIC_INLINE static __inline +#endif +#ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE static __forceinline +#endif +#ifndef __NO_RETURN + #define __NO_RETURN __declspec(noreturn) +#endif +#ifndef __USED + #define __USED __attribute__((used)) +#endif +#ifndef __WEAK + #define __WEAK __attribute__((weak)) +#endif +#ifndef __PACKED + #define __PACKED __attribute__((packed)) +#endif +#ifndef __PACKED_STRUCT + #define __PACKED_STRUCT __packed struct +#endif +#ifndef __PACKED_UNION + #define __PACKED_UNION __packed union +#endif +#ifndef __UNALIGNED_UINT32 /* deprecated */ + #define __UNALIGNED_UINT32(x) (*((__packed uint32_t *)(x))) +#endif +#ifndef __UNALIGNED_UINT16_WRITE + #define __UNALIGNED_UINT16_WRITE(addr, val) ((*((__packed uint16_t *)(addr))) = (val)) +#endif +#ifndef __UNALIGNED_UINT16_READ + #define __UNALIGNED_UINT16_READ(addr) (*((const __packed uint16_t *)(addr))) +#endif +#ifndef __UNALIGNED_UINT32_WRITE + #define __UNALIGNED_UINT32_WRITE(addr, val) ((*((__packed uint32_t *)(addr))) = (val)) +#endif +#ifndef __UNALIGNED_UINT32_READ + #define __UNALIGNED_UINT32_READ(addr) (*((const __packed uint32_t *)(addr))) +#endif +#ifndef __ALIGNED + #define __ALIGNED(x) __attribute__((aligned(x))) +#endif +#ifndef __RESTRICT + #define __RESTRICT __restrict +#endif +#ifndef __COMPILER_BARRIER + #define __COMPILER_BARRIER() __memory_changed() +#endif + +/* ######################### Startup and Lowlevel Init ######################## */ + +#ifndef __PROGRAM_START +#define __PROGRAM_START __main +#endif + +#ifndef __INITIAL_SP +#define __INITIAL_SP Image$$ARM_LIB_STACK$$ZI$$Limit +#endif + +#ifndef __STACK_LIMIT +#define __STACK_LIMIT Image$$ARM_LIB_STACK$$ZI$$Base +#endif + +#ifndef __VECTOR_TABLE +#define __VECTOR_TABLE __Vectors +#endif + +#ifndef __VECTOR_TABLE_ATTRIBUTE +#define __VECTOR_TABLE_ATTRIBUTE __attribute((used, section("RESET"))) +#endif + +/* ########################### Core Function Access ########################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions + @{ + */ + +/** + \brief Enable IRQ Interrupts + \details Enables IRQ interrupts by clearing the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +/* intrinsic void __enable_irq(); */ + + +/** + \brief Disable IRQ Interrupts + \details Disables IRQ interrupts by setting the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +/* intrinsic void __disable_irq(); */ + +/** + \brief Get Control Register + \details Returns the content of the Control Register. + \return Control Register value + */ +__STATIC_INLINE uint32_t __get_CONTROL(void) +{ + register uint32_t __regControl __ASM("control"); + return(__regControl); +} + + +/** + \brief Set Control Register + \details Writes the given value to the Control Register. + \param [in] control Control Register value to set + */ +__STATIC_INLINE void __set_CONTROL(uint32_t control) +{ + register uint32_t __regControl __ASM("control"); + __regControl = control; +} + + +/** + \brief Get IPSR Register + \details Returns the content of the IPSR Register. + \return IPSR Register value + */ +__STATIC_INLINE uint32_t __get_IPSR(void) +{ + register uint32_t __regIPSR __ASM("ipsr"); + return(__regIPSR); +} + + +/** + \brief Get APSR Register + \details Returns the content of the APSR Register. + \return APSR Register value + */ +__STATIC_INLINE uint32_t __get_APSR(void) +{ + register uint32_t __regAPSR __ASM("apsr"); + return(__regAPSR); +} + + +/** + \brief Get xPSR Register + \details Returns the content of the xPSR Register. + \return xPSR Register value + */ +__STATIC_INLINE uint32_t __get_xPSR(void) +{ + register uint32_t __regXPSR __ASM("xpsr"); + return(__regXPSR); +} + + +/** + \brief Get Process Stack Pointer + \details Returns the current value of the Process Stack Pointer (PSP). + \return PSP Register value + */ +__STATIC_INLINE uint32_t __get_PSP(void) +{ + register uint32_t __regProcessStackPointer __ASM("psp"); + return(__regProcessStackPointer); +} + + +/** + \brief Set Process Stack Pointer + \details Assigns the given value to the Process Stack Pointer (PSP). + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_INLINE void __set_PSP(uint32_t topOfProcStack) +{ + register uint32_t __regProcessStackPointer __ASM("psp"); + __regProcessStackPointer = topOfProcStack; +} + + +/** + \brief Get Main Stack Pointer + \details Returns the current value of the Main Stack Pointer (MSP). + \return MSP Register value + */ +__STATIC_INLINE uint32_t __get_MSP(void) +{ + register uint32_t __regMainStackPointer __ASM("msp"); + return(__regMainStackPointer); +} + + +/** + \brief Set Main Stack Pointer + \details Assigns the given value to the Main Stack Pointer (MSP). + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_INLINE void __set_MSP(uint32_t topOfMainStack) +{ + register uint32_t __regMainStackPointer __ASM("msp"); + __regMainStackPointer = topOfMainStack; +} + + +/** + \brief Get Priority Mask + \details Returns the current state of the priority mask bit from the Priority Mask Register. + \return Priority Mask value + */ +__STATIC_INLINE uint32_t __get_PRIMASK(void) +{ + register uint32_t __regPriMask __ASM("primask"); + return(__regPriMask); +} + + +/** + \brief Set Priority Mask + \details Assigns the given value to the Priority Mask Register. + \param [in] priMask Priority Mask + */ +__STATIC_INLINE void __set_PRIMASK(uint32_t priMask) +{ + register uint32_t __regPriMask __ASM("primask"); + __regPriMask = (priMask); +} + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) + +/** + \brief Enable FIQ + \details Enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __enable_fault_irq __enable_fiq + + +/** + \brief Disable FIQ + \details Disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __disable_fault_irq __disable_fiq + + +/** + \brief Get Base Priority + \details Returns the current value of the Base Priority register. + \return Base Priority register value + */ +__STATIC_INLINE uint32_t __get_BASEPRI(void) +{ + register uint32_t __regBasePri __ASM("basepri"); + return(__regBasePri); +} + + +/** + \brief Set Base Priority + \details Assigns the given value to the Base Priority register. + \param [in] basePri Base Priority value to set + */ +__STATIC_INLINE void __set_BASEPRI(uint32_t basePri) +{ + register uint32_t __regBasePri __ASM("basepri"); + __regBasePri = (basePri & 0xFFU); +} + + +/** + \brief Set Base Priority with condition + \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled, + or the new value increases the BASEPRI priority level. + \param [in] basePri Base Priority value to set + */ +__STATIC_INLINE void __set_BASEPRI_MAX(uint32_t basePri) +{ + register uint32_t __regBasePriMax __ASM("basepri_max"); + __regBasePriMax = (basePri & 0xFFU); +} + + +/** + \brief Get Fault Mask + \details Returns the current value of the Fault Mask register. + \return Fault Mask register value + */ +__STATIC_INLINE uint32_t __get_FAULTMASK(void) +{ + register uint32_t __regFaultMask __ASM("faultmask"); + return(__regFaultMask); +} + + +/** + \brief Set Fault Mask + \details Assigns the given value to the Fault Mask register. + \param [in] faultMask Fault Mask value to set + */ +__STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask) +{ + register uint32_t __regFaultMask __ASM("faultmask"); + __regFaultMask = (faultMask & (uint32_t)1U); +} + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */ + + +/** + \brief Get FPSCR + \details Returns the current value of the Floating Point Status/Control register. + \return Floating Point Status/Control register value + */ +__STATIC_INLINE uint32_t __get_FPSCR(void) +{ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) + register uint32_t __regfpscr __ASM("fpscr"); + return(__regfpscr); +#else + return(0U); +#endif +} + + +/** + \brief Set FPSCR + \details Assigns the given value to the Floating Point Status/Control register. + \param [in] fpscr Floating Point Status/Control value to set + */ +__STATIC_INLINE void __set_FPSCR(uint32_t fpscr) +{ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) + register uint32_t __regfpscr __ASM("fpscr"); + __regfpscr = (fpscr); +#else + (void)fpscr; +#endif +} + + +/*@} end of CMSIS_Core_RegAccFunctions */ + + +/* ########################## Core Instruction Access ######################### */ +/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface + Access to dedicated instructions + @{ +*/ + +/** + \brief No Operation + \details No Operation does nothing. This instruction can be used for code alignment purposes. + */ +#define __NOP __nop + + +/** + \brief Wait For Interrupt + \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs. + */ +#define __WFI __wfi + + +/** + \brief Wait For Event + \details Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +#define __WFE __wfe + + +/** + \brief Send Event + \details Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +#define __SEV __sev + + +/** + \brief Instruction Synchronization Barrier + \details Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or memory, + after the instruction has been completed. + */ +#define __ISB() do {\ + __schedule_barrier();\ + __isb(0xF);\ + __schedule_barrier();\ + } while (0U) + +/** + \brief Data Synchronization Barrier + \details Acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +#define __DSB() do {\ + __schedule_barrier();\ + __dsb(0xF);\ + __schedule_barrier();\ + } while (0U) + +/** + \brief Data Memory Barrier + \details Ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +#define __DMB() do {\ + __schedule_barrier();\ + __dmb(0xF);\ + __schedule_barrier();\ + } while (0U) + + +/** + \brief Reverse byte order (32 bit) + \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412. + \param [in] value Value to reverse + \return Reversed value + */ +#define __REV __rev + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856. + \param [in] value Value to reverse + \return Reversed value + */ +#ifndef __NO_EMBEDDED_ASM +__attribute__((section(".rev16_text"))) __STATIC_INLINE __ASM uint32_t __REV16(uint32_t value) +{ + rev16 r0, r0 + bx lr +} +#endif + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000. + \param [in] value Value to reverse + \return Reversed value + */ +#ifndef __NO_EMBEDDED_ASM +__attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int16_t __REVSH(int16_t value) +{ + revsh r0, r0 + bx lr +} +#endif + + +/** + \brief Rotate Right in unsigned value (32 bit) + \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + \param [in] op1 Value to rotate + \param [in] op2 Number of Bits to rotate + \return Rotated value + */ +#define __ROR __ror + + +/** + \brief Breakpoint + \details Causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __breakpoint(value) + + +/** + \brief Reverse bit order of value + \details Reverses the bit order of the given value. + \param [in] value Value to reverse + \return Reversed value + */ +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) + #define __RBIT __rbit +#else +__attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value) +{ + uint32_t result; + uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */ + + result = value; /* r will be reversed bits of v; first get LSB of v */ + for (value >>= 1U; value != 0U; value >>= 1U) + { + result <<= 1U; + result |= value & 1U; + s--; + } + result <<= s; /* shift when v's highest bits are zero */ + return result; +} +#endif + + +/** + \brief Count leading zeros + \details Counts the number of leading zeros of a data value. + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +#define __CLZ __clz + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) + +/** + \brief LDR Exclusive (8 bit) + \details Executes a exclusive LDR instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020) + #define __LDREXB(ptr) ((uint8_t ) __ldrex(ptr)) +#else + #define __LDREXB(ptr) _Pragma("push") _Pragma("diag_suppress 3731") ((uint8_t ) __ldrex(ptr)) _Pragma("pop") +#endif + + +/** + \brief LDR Exclusive (16 bit) + \details Executes a exclusive LDR instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020) + #define __LDREXH(ptr) ((uint16_t) __ldrex(ptr)) +#else + #define __LDREXH(ptr) _Pragma("push") _Pragma("diag_suppress 3731") ((uint16_t) __ldrex(ptr)) _Pragma("pop") +#endif + + +/** + \brief LDR Exclusive (32 bit) + \details Executes a exclusive LDR instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020) + #define __LDREXW(ptr) ((uint32_t ) __ldrex(ptr)) +#else + #define __LDREXW(ptr) _Pragma("push") _Pragma("diag_suppress 3731") ((uint32_t ) __ldrex(ptr)) _Pragma("pop") +#endif + + +/** + \brief STR Exclusive (8 bit) + \details Executes a exclusive STR instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020) + #define __STREXB(value, ptr) __strex(value, ptr) +#else + #define __STREXB(value, ptr) _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr) _Pragma("pop") +#endif + + +/** + \brief STR Exclusive (16 bit) + \details Executes a exclusive STR instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020) + #define __STREXH(value, ptr) __strex(value, ptr) +#else + #define __STREXH(value, ptr) _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr) _Pragma("pop") +#endif + + +/** + \brief STR Exclusive (32 bit) + \details Executes a exclusive STR instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020) + #define __STREXW(value, ptr) __strex(value, ptr) +#else + #define __STREXW(value, ptr) _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr) _Pragma("pop") +#endif + + +/** + \brief Remove the exclusive lock + \details Removes the exclusive lock which is created by LDREX. + */ +#define __CLREX __clrex + + +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT __ssat + + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT __usat + + +/** + \brief Rotate Right with Extend (32 bit) + \details Moves each bit of a bitstring right by one bit. + The carry input is shifted in at the left end of the bitstring. + \param [in] value Value to rotate + \return Rotated value + */ +#ifndef __NO_EMBEDDED_ASM +__attribute__((section(".rrx_text"))) __STATIC_INLINE __ASM uint32_t __RRX(uint32_t value) +{ + rrx r0, r0 + bx lr +} +#endif + + +/** + \brief LDRT Unprivileged (8 bit) + \details Executes a Unprivileged LDRT instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#define __LDRBT(ptr) ((uint8_t ) __ldrt(ptr)) + + +/** + \brief LDRT Unprivileged (16 bit) + \details Executes a Unprivileged LDRT instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#define __LDRHT(ptr) ((uint16_t) __ldrt(ptr)) + + +/** + \brief LDRT Unprivileged (32 bit) + \details Executes a Unprivileged LDRT instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#define __LDRT(ptr) ((uint32_t ) __ldrt(ptr)) + + +/** + \brief STRT Unprivileged (8 bit) + \details Executes a Unprivileged STRT instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +#define __STRBT(value, ptr) __strt(value, ptr) + + +/** + \brief STRT Unprivileged (16 bit) + \details Executes a Unprivileged STRT instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +#define __STRHT(value, ptr) __strt(value, ptr) + + +/** + \brief STRT Unprivileged (32 bit) + \details Executes a Unprivileged STRT instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +#define __STRT(value, ptr) __strt(value, ptr) + +#else /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */ + +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +__attribute__((always_inline)) __STATIC_INLINE int32_t __SSAT(int32_t val, uint32_t sat) +{ + if ((sat >= 1U) && (sat <= 32U)) + { + const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U); + const int32_t min = -1 - max ; + if (val > max) + { + return max; + } + else if (val < min) + { + return min; + } + } + return val; +} + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +__attribute__((always_inline)) __STATIC_INLINE uint32_t __USAT(int32_t val, uint32_t sat) +{ + if (sat <= 31U) + { + const uint32_t max = ((1U << sat) - 1U); + if (val > (int32_t)max) + { + return max; + } + else if (val < 0) + { + return 0U; + } + } + return (uint32_t)val; +} + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */ + +/*@}*/ /* end of group CMSIS_Core_InstructionInterface */ + + +/* ################### Compiler specific Intrinsics ########################### */ +/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics + Access to dedicated SIMD instructions + @{ +*/ + +#if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) + +#define __SADD8 __sadd8 +#define __QADD8 __qadd8 +#define __SHADD8 __shadd8 +#define __UADD8 __uadd8 +#define __UQADD8 __uqadd8 +#define __UHADD8 __uhadd8 +#define __SSUB8 __ssub8 +#define __QSUB8 __qsub8 +#define __SHSUB8 __shsub8 +#define __USUB8 __usub8 +#define __UQSUB8 __uqsub8 +#define __UHSUB8 __uhsub8 +#define __SADD16 __sadd16 +#define __QADD16 __qadd16 +#define __SHADD16 __shadd16 +#define __UADD16 __uadd16 +#define __UQADD16 __uqadd16 +#define __UHADD16 __uhadd16 +#define __SSUB16 __ssub16 +#define __QSUB16 __qsub16 +#define __SHSUB16 __shsub16 +#define __USUB16 __usub16 +#define __UQSUB16 __uqsub16 +#define __UHSUB16 __uhsub16 +#define __SASX __sasx +#define __QASX __qasx +#define __SHASX __shasx +#define __UASX __uasx +#define __UQASX __uqasx +#define __UHASX __uhasx +#define __SSAX __ssax +#define __QSAX __qsax +#define __SHSAX __shsax +#define __USAX __usax +#define __UQSAX __uqsax +#define __UHSAX __uhsax +#define __USAD8 __usad8 +#define __USADA8 __usada8 +#define __SSAT16 __ssat16 +#define __USAT16 __usat16 +#define __UXTB16 __uxtb16 +#define __UXTAB16 __uxtab16 +#define __SXTB16 __sxtb16 +#define __SXTAB16 __sxtab16 +#define __SMUAD __smuad +#define __SMUADX __smuadx +#define __SMLAD __smlad +#define __SMLADX __smladx +#define __SMLALD __smlald +#define __SMLALDX __smlaldx +#define __SMUSD __smusd +#define __SMUSDX __smusdx +#define __SMLSD __smlsd +#define __SMLSDX __smlsdx +#define __SMLSLD __smlsld +#define __SMLSLDX __smlsldx +#define __SEL __sel +#define __QADD __qadd +#define __QSUB __qsub + +#define __PKHBT(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) | \ + ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) ) + +#define __PKHTB(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0xFFFF0000UL) | \ + ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL) ) + +#define __SMMLA(ARG1,ARG2,ARG3) ( (int32_t)((((int64_t)(ARG1) * (ARG2)) + \ + ((int64_t)(ARG3) << 32U) ) >> 32U)) + +#endif /* ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */ +/*@} end of group CMSIS_SIMD_intrinsics */ + + +#endif /* __CMSIS_ARMCC_H */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang.h new file mode 100644 index 0000000000..e917f357a3 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang.h @@ -0,0 +1,1444 @@ +/**************************************************************************//** + * @file cmsis_armclang.h + * @brief CMSIS compiler armclang (Arm Compiler 6) header file + * @version V5.2.0 + * @date 08. May 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/*lint -esym(9058, IRQn)*/ /* disable MISRA 2012 Rule 2.4 for IRQn */ + +#ifndef __CMSIS_ARMCLANG_H +#define __CMSIS_ARMCLANG_H + +#pragma clang system_header /* treat file as system include file */ + +#ifndef __ARM_COMPAT_H +#include /* Compatibility header for Arm Compiler 5 intrinsics */ +#endif + +/* CMSIS compiler specific defines */ +#ifndef __ASM + #define __ASM __asm +#endif +#ifndef __INLINE + #define __INLINE __inline +#endif +#ifndef __STATIC_INLINE + #define __STATIC_INLINE static __inline +#endif +#ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE __attribute__((always_inline)) static __inline +#endif +#ifndef __NO_RETURN + #define __NO_RETURN __attribute__((__noreturn__)) +#endif +#ifndef __USED + #define __USED __attribute__((used)) +#endif +#ifndef __WEAK + #define __WEAK __attribute__((weak)) +#endif +#ifndef __PACKED + #define __PACKED __attribute__((packed, aligned(1))) +#endif +#ifndef __PACKED_STRUCT + #define __PACKED_STRUCT struct __attribute__((packed, aligned(1))) +#endif +#ifndef __PACKED_UNION + #define __PACKED_UNION union __attribute__((packed, aligned(1))) +#endif +#ifndef __UNALIGNED_UINT32 /* deprecated */ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT32)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32 */ + struct __attribute__((packed)) T_UINT32 { uint32_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v) +#endif +#ifndef __UNALIGNED_UINT16_WRITE + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT16_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_WRITE */ + __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val)) +#endif +#ifndef __UNALIGNED_UINT16_READ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT16_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_READ */ + __PACKED_STRUCT T_UINT16_READ { uint16_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v) +#endif +#ifndef __UNALIGNED_UINT32_WRITE + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT32_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_WRITE */ + __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val)) +#endif +#ifndef __UNALIGNED_UINT32_READ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT32_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_READ */ + __PACKED_STRUCT T_UINT32_READ { uint32_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v) +#endif +#ifndef __ALIGNED + #define __ALIGNED(x) __attribute__((aligned(x))) +#endif +#ifndef __RESTRICT + #define __RESTRICT __restrict +#endif +#ifndef __COMPILER_BARRIER + #define __COMPILER_BARRIER() __ASM volatile("":::"memory") +#endif + +/* ######################### Startup and Lowlevel Init ######################## */ + +#ifndef __PROGRAM_START +#define __PROGRAM_START __main +#endif + +#ifndef __INITIAL_SP +#define __INITIAL_SP Image$$ARM_LIB_STACK$$ZI$$Limit +#endif + +#ifndef __STACK_LIMIT +#define __STACK_LIMIT Image$$ARM_LIB_STACK$$ZI$$Base +#endif + +#ifndef __VECTOR_TABLE +#define __VECTOR_TABLE __Vectors +#endif + +#ifndef __VECTOR_TABLE_ATTRIBUTE +#define __VECTOR_TABLE_ATTRIBUTE __attribute((used, section("RESET"))) +#endif + +/* ########################### Core Function Access ########################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions + @{ + */ + +/** + \brief Enable IRQ Interrupts + \details Enables IRQ interrupts by clearing the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +/* intrinsic void __enable_irq(); see arm_compat.h */ + + +/** + \brief Disable IRQ Interrupts + \details Disables IRQ interrupts by setting the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +/* intrinsic void __disable_irq(); see arm_compat.h */ + + +/** + \brief Get Control Register + \details Returns the content of the Control Register. + \return Control Register value + */ +__STATIC_FORCEINLINE uint32_t __get_CONTROL(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Control Register (non-secure) + \details Returns the content of the non-secure Control Register when in secure mode. + \return non-secure Control Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Control Register + \details Writes the given value to the Control Register. + \param [in] control Control Register value to set + */ +__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control) +{ + __ASM volatile ("MSR control, %0" : : "r" (control) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Control Register (non-secure) + \details Writes the given value to the non-secure Control Register when in secure state. + \param [in] control Control Register value to set + */ +__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control) +{ + __ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory"); +} +#endif + + +/** + \brief Get IPSR Register + \details Returns the content of the IPSR Register. + \return IPSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_IPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, ipsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get APSR Register + \details Returns the content of the APSR Register. + \return APSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_APSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, apsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get xPSR Register + \details Returns the content of the xPSR Register. + \return xPSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_xPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, xpsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get Process Stack Pointer + \details Returns the current value of the Process Stack Pointer (PSP). + \return PSP Register value + */ +__STATIC_FORCEINLINE uint32_t __get_PSP(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, psp" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Process Stack Pointer (non-secure) + \details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state. + \return PSP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, psp_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Process Stack Pointer + \details Assigns the given value to the Process Stack Pointer (PSP). + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : ); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Process Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state. + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : ); +} +#endif + + +/** + \brief Get Main Stack Pointer + \details Returns the current value of the Main Stack Pointer (MSP). + \return MSP Register value + */ +__STATIC_FORCEINLINE uint32_t __get_MSP(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, msp" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Main Stack Pointer (non-secure) + \details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state. + \return MSP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, msp_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Main Stack Pointer + \details Assigns the given value to the Main Stack Pointer (MSP). + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : ); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Main Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state. + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : ); +} +#endif + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Stack Pointer (non-secure) + \details Returns the current value of the non-secure Stack Pointer (SP) when in secure state. + \return SP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, sp_ns" : "=r" (result) ); + return(result); +} + + +/** + \brief Set Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state. + \param [in] topOfStack Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack) +{ + __ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : ); +} +#endif + + +/** + \brief Get Priority Mask + \details Returns the current state of the priority mask bit from the Priority Mask Register. + \return Priority Mask value + */ +__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Priority Mask (non-secure) + \details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state. + \return Priority Mask value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Priority Mask + \details Assigns the given value to the Priority Mask Register. + \param [in] priMask Priority Mask + */ +__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask) +{ + __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Priority Mask (non-secure) + \details Assigns the given value to the non-secure Priority Mask Register when in secure state. + \param [in] priMask Priority Mask + */ +__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask) +{ + __ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory"); +} +#endif + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) +/** + \brief Enable FIQ + \details Enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __enable_fault_irq __enable_fiq /* see arm_compat.h */ + + +/** + \brief Disable FIQ + \details Disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __disable_fault_irq __disable_fiq /* see arm_compat.h */ + + +/** + \brief Get Base Priority + \details Returns the current value of the Base Priority register. + \return Base Priority register value + */ +__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Base Priority (non-secure) + \details Returns the current value of the non-secure Base Priority register when in secure state. + \return Base Priority register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Base Priority + \details Assigns the given value to the Base Priority register. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri) +{ + __ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Base Priority (non-secure) + \details Assigns the given value to the non-secure Base Priority register when in secure state. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri) +{ + __ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory"); +} +#endif + + +/** + \brief Set Base Priority with condition + \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled, + or the new value increases the BASEPRI priority level. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri) +{ + __ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory"); +} + + +/** + \brief Get Fault Mask + \details Returns the current value of the Fault Mask register. + \return Fault Mask register value + */ +__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Fault Mask (non-secure) + \details Returns the current value of the non-secure Fault Mask register when in secure state. + \return Fault Mask register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Fault Mask + \details Assigns the given value to the Fault Mask register. + \param [in] faultMask Fault Mask value to set + */ +__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Fault Mask (non-secure) + \details Assigns the given value to the non-secure Fault Mask register when in secure state. + \param [in] faultMask Fault Mask value to set + */ +__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory"); +} +#endif + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) + +/** + \brief Get Process Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always in non-secure + mode. + + \details Returns the current value of the Process Stack Pointer Limit (PSPLIM). + \return PSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, psplim" : "=r" (result) ); + return result; +#endif +} + +#if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Process Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always in non-secure + mode. + + \details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state. + \return PSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, psplim_ns" : "=r" (result) ); + return result; +#endif +} +#endif + + +/** + \brief Set Process Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored in non-secure + mode. + + \details Assigns the given value to the Process Stack Pointer Limit (PSPLIM). + \param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)ProcStackPtrLimit; +#else + __ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit)); +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Process Stack Pointer (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored in non-secure + mode. + + \details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state. + \param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)ProcStackPtrLimit; +#else + __ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit)); +#endif +} +#endif + + +/** + \brief Get Main Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always. + + \details Returns the current value of the Main Stack Pointer Limit (MSPLIM). + \return MSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, msplim" : "=r" (result) ); + return result; +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Main Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always. + + \details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state. + \return MSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, msplim_ns" : "=r" (result) ); + return result; +#endif +} +#endif + + +/** + \brief Set Main Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored. + + \details Assigns the given value to the Main Stack Pointer Limit (MSPLIM). + \param [in] MainStackPtrLimit Main Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + (void)MainStackPtrLimit; +#else + __ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit)); +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Main Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored. + + \details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state. + \param [in] MainStackPtrLimit Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + (void)MainStackPtrLimit; +#else + __ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit)); +#endif +} +#endif + +#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + +/** + \brief Get FPSCR + \details Returns the current value of the Floating Point Status/Control register. + \return Floating Point Status/Control register value + */ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) +#define __get_FPSCR (uint32_t)__builtin_arm_get_fpscr +#else +#define __get_FPSCR() ((uint32_t)0U) +#endif + +/** + \brief Set FPSCR + \details Assigns the given value to the Floating Point Status/Control register. + \param [in] fpscr Floating Point Status/Control value to set + */ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) +#define __set_FPSCR __builtin_arm_set_fpscr +#else +#define __set_FPSCR(x) ((void)(x)) +#endif + + +/*@} end of CMSIS_Core_RegAccFunctions */ + + +/* ########################## Core Instruction Access ######################### */ +/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface + Access to dedicated instructions + @{ +*/ + +/* Define macros for porting to both thumb1 and thumb2. + * For thumb1, use low register (r0-r7), specified by constraint "l" + * Otherwise, use general registers, specified by constraint "r" */ +#if defined (__thumb__) && !defined (__thumb2__) +#define __CMSIS_GCC_OUT_REG(r) "=l" (r) +#define __CMSIS_GCC_RW_REG(r) "+l" (r) +#define __CMSIS_GCC_USE_REG(r) "l" (r) +#else +#define __CMSIS_GCC_OUT_REG(r) "=r" (r) +#define __CMSIS_GCC_RW_REG(r) "+r" (r) +#define __CMSIS_GCC_USE_REG(r) "r" (r) +#endif + +/** + \brief No Operation + \details No Operation does nothing. This instruction can be used for code alignment purposes. + */ +#define __NOP __builtin_arm_nop + +/** + \brief Wait For Interrupt + \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs. + */ +#define __WFI __builtin_arm_wfi + + +/** + \brief Wait For Event + \details Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +#define __WFE __builtin_arm_wfe + + +/** + \brief Send Event + \details Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +#define __SEV __builtin_arm_sev + + +/** + \brief Instruction Synchronization Barrier + \details Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or memory, + after the instruction has been completed. + */ +#define __ISB() __builtin_arm_isb(0xF) + +/** + \brief Data Synchronization Barrier + \details Acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +#define __DSB() __builtin_arm_dsb(0xF) + + +/** + \brief Data Memory Barrier + \details Ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +#define __DMB() __builtin_arm_dmb(0xF) + + +/** + \brief Reverse byte order (32 bit) + \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412. + \param [in] value Value to reverse + \return Reversed value + */ +#define __REV(value) __builtin_bswap32(value) + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856. + \param [in] value Value to reverse + \return Reversed value + */ +#define __REV16(value) __ROR(__REV(value), 16) + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000. + \param [in] value Value to reverse + \return Reversed value + */ +#define __REVSH(value) (int16_t)__builtin_bswap16(value) + + +/** + \brief Rotate Right in unsigned value (32 bit) + \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + \param [in] op1 Value to rotate + \param [in] op2 Number of Bits to rotate + \return Rotated value + */ +__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2) +{ + op2 %= 32U; + if (op2 == 0U) + { + return op1; + } + return (op1 >> op2) | (op1 << (32U - op2)); +} + + +/** + \brief Breakpoint + \details Causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __ASM volatile ("bkpt "#value) + + +/** + \brief Reverse bit order of value + \details Reverses the bit order of the given value. + \param [in] value Value to reverse + \return Reversed value + */ +#define __RBIT __builtin_arm_rbit + +/** + \brief Count leading zeros + \details Counts the number of leading zeros of a data value. + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +__STATIC_FORCEINLINE uint8_t __CLZ(uint32_t value) +{ + /* Even though __builtin_clz produces a CLZ instruction on ARM, formally + __builtin_clz(0) is undefined behaviour, so handle this case specially. + This guarantees ARM-compatible results if happening to compile on a non-ARM + target, and ensures the compiler doesn't decide to activate any + optimisations using the logic "value was passed to __builtin_clz, so it + is non-zero". + ARM Compiler 6.10 and possibly earlier will optimise this test away, leaving a + single CLZ instruction. + */ + if (value == 0U) + { + return 32U; + } + return __builtin_clz(value); +} + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) +/** + \brief LDR Exclusive (8 bit) + \details Executes a exclusive LDR instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#define __LDREXB (uint8_t)__builtin_arm_ldrex + + +/** + \brief LDR Exclusive (16 bit) + \details Executes a exclusive LDR instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#define __LDREXH (uint16_t)__builtin_arm_ldrex + + +/** + \brief LDR Exclusive (32 bit) + \details Executes a exclusive LDR instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#define __LDREXW (uint32_t)__builtin_arm_ldrex + + +/** + \brief STR Exclusive (8 bit) + \details Executes a exclusive STR instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXB (uint32_t)__builtin_arm_strex + + +/** + \brief STR Exclusive (16 bit) + \details Executes a exclusive STR instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXH (uint32_t)__builtin_arm_strex + + +/** + \brief STR Exclusive (32 bit) + \details Executes a exclusive STR instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXW (uint32_t)__builtin_arm_strex + + +/** + \brief Remove the exclusive lock + \details Removes the exclusive lock which is created by LDREX. + */ +#define __CLREX __builtin_arm_clrex + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) + +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT __builtin_arm_ssat + + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT __builtin_arm_usat + + +/** + \brief Rotate Right with Extend (32 bit) + \details Moves each bit of a bitstring right by one bit. + The carry input is shifted in at the left end of the bitstring. + \param [in] value Value to rotate + \return Rotated value + */ +__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rrx %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +} + + +/** + \brief LDRT Unprivileged (8 bit) + \details Executes a Unprivileged LDRT instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint8_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDRT Unprivileged (16 bit) + \details Executes a Unprivileged LDRT instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint16_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDRT Unprivileged (32 bit) + \details Executes a Unprivileged LDRT instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) ); + return(result); +} + + +/** + \brief STRT Unprivileged (8 bit) + \details Executes a Unprivileged STRT instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr) +{ + __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief STRT Unprivileged (16 bit) + \details Executes a Unprivileged STRT instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr) +{ + __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief STRT Unprivileged (32 bit) + \details Executes a Unprivileged STRT instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr) +{ + __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) ); +} + +#else /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat) +{ + if ((sat >= 1U) && (sat <= 32U)) + { + const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U); + const int32_t min = -1 - max ; + if (val > max) + { + return max; + } + else if (val < min) + { + return min; + } + } + return val; +} + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat) +{ + if (sat <= 31U) + { + const uint32_t max = ((1U << sat) - 1U); + if (val > (int32_t)max) + { + return max; + } + else if (val < 0) + { + return 0U; + } + } + return (uint32_t)val; +} + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) +/** + \brief Load-Acquire (8 bit) + \details Executes a LDAB instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint8_t) result); +} + + +/** + \brief Load-Acquire (16 bit) + \details Executes a LDAH instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint16_t) result); +} + + +/** + \brief Load-Acquire (32 bit) + \details Executes a LDA instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) ); + return(result); +} + + +/** + \brief Store-Release (8 bit) + \details Executes a STLB instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr) +{ + __ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Store-Release (16 bit) + \details Executes a STLH instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr) +{ + __ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Store-Release (32 bit) + \details Executes a STL instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr) +{ + __ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Load-Acquire Exclusive (8 bit) + \details Executes a LDAB exclusive instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#define __LDAEXB (uint8_t)__builtin_arm_ldaex + + +/** + \brief Load-Acquire Exclusive (16 bit) + \details Executes a LDAH exclusive instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#define __LDAEXH (uint16_t)__builtin_arm_ldaex + + +/** + \brief Load-Acquire Exclusive (32 bit) + \details Executes a LDA exclusive instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#define __LDAEX (uint32_t)__builtin_arm_ldaex + + +/** + \brief Store-Release Exclusive (8 bit) + \details Executes a STLB exclusive instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STLEXB (uint32_t)__builtin_arm_stlex + + +/** + \brief Store-Release Exclusive (16 bit) + \details Executes a STLH exclusive instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STLEXH (uint32_t)__builtin_arm_stlex + + +/** + \brief Store-Release Exclusive (32 bit) + \details Executes a STL exclusive instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STLEX (uint32_t)__builtin_arm_stlex + +#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + +/*@}*/ /* end of group CMSIS_Core_InstructionInterface */ + + +/* ################### Compiler specific Intrinsics ########################### */ +/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics + Access to dedicated SIMD instructions + @{ +*/ + +#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1)) + +#define __SADD8 __builtin_arm_sadd8 +#define __QADD8 __builtin_arm_qadd8 +#define __SHADD8 __builtin_arm_shadd8 +#define __UADD8 __builtin_arm_uadd8 +#define __UQADD8 __builtin_arm_uqadd8 +#define __UHADD8 __builtin_arm_uhadd8 +#define __SSUB8 __builtin_arm_ssub8 +#define __QSUB8 __builtin_arm_qsub8 +#define __SHSUB8 __builtin_arm_shsub8 +#define __USUB8 __builtin_arm_usub8 +#define __UQSUB8 __builtin_arm_uqsub8 +#define __UHSUB8 __builtin_arm_uhsub8 +#define __SADD16 __builtin_arm_sadd16 +#define __QADD16 __builtin_arm_qadd16 +#define __SHADD16 __builtin_arm_shadd16 +#define __UADD16 __builtin_arm_uadd16 +#define __UQADD16 __builtin_arm_uqadd16 +#define __UHADD16 __builtin_arm_uhadd16 +#define __SSUB16 __builtin_arm_ssub16 +#define __QSUB16 __builtin_arm_qsub16 +#define __SHSUB16 __builtin_arm_shsub16 +#define __USUB16 __builtin_arm_usub16 +#define __UQSUB16 __builtin_arm_uqsub16 +#define __UHSUB16 __builtin_arm_uhsub16 +#define __SASX __builtin_arm_sasx +#define __QASX __builtin_arm_qasx +#define __SHASX __builtin_arm_shasx +#define __UASX __builtin_arm_uasx +#define __UQASX __builtin_arm_uqasx +#define __UHASX __builtin_arm_uhasx +#define __SSAX __builtin_arm_ssax +#define __QSAX __builtin_arm_qsax +#define __SHSAX __builtin_arm_shsax +#define __USAX __builtin_arm_usax +#define __UQSAX __builtin_arm_uqsax +#define __UHSAX __builtin_arm_uhsax +#define __USAD8 __builtin_arm_usad8 +#define __USADA8 __builtin_arm_usada8 +#define __SSAT16 __builtin_arm_ssat16 +#define __USAT16 __builtin_arm_usat16 +#define __UXTB16 __builtin_arm_uxtb16 +#define __UXTAB16 __builtin_arm_uxtab16 +#define __SXTB16 __builtin_arm_sxtb16 +#define __SXTAB16 __builtin_arm_sxtab16 +#define __SMUAD __builtin_arm_smuad +#define __SMUADX __builtin_arm_smuadx +#define __SMLAD __builtin_arm_smlad +#define __SMLADX __builtin_arm_smladx +#define __SMLALD __builtin_arm_smlald +#define __SMLALDX __builtin_arm_smlaldx +#define __SMUSD __builtin_arm_smusd +#define __SMUSDX __builtin_arm_smusdx +#define __SMLSD __builtin_arm_smlsd +#define __SMLSDX __builtin_arm_smlsdx +#define __SMLSLD __builtin_arm_smlsld +#define __SMLSLDX __builtin_arm_smlsldx +#define __SEL __builtin_arm_sel +#define __QADD __builtin_arm_qadd +#define __QSUB __builtin_arm_qsub + +#define __PKHBT(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) | \ + ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) ) + +#define __PKHTB(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0xFFFF0000UL) | \ + ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL) ) + +__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3) +{ + int32_t result; + + __ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +#endif /* (__ARM_FEATURE_DSP == 1) */ +/*@} end of group CMSIS_SIMD_intrinsics */ + + +#endif /* __CMSIS_ARMCLANG_H */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang_ltm.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang_ltm.h new file mode 100644 index 0000000000..feec324059 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_armclang_ltm.h @@ -0,0 +1,1891 @@ +/**************************************************************************//** + * @file cmsis_armclang_ltm.h + * @brief CMSIS compiler armclang (Arm Compiler 6) header file + * @version V1.2.0 + * @date 08. May 2019 + ******************************************************************************/ +/* + * Copyright (c) 2018-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/*lint -esym(9058, IRQn)*/ /* disable MISRA 2012 Rule 2.4 for IRQn */ + +#ifndef __CMSIS_ARMCLANG_H +#define __CMSIS_ARMCLANG_H + +#pragma clang system_header /* treat file as system include file */ + +#ifndef __ARM_COMPAT_H +#include /* Compatibility header for Arm Compiler 5 intrinsics */ +#endif + +/* CMSIS compiler specific defines */ +#ifndef __ASM + #define __ASM __asm +#endif +#ifndef __INLINE + #define __INLINE __inline +#endif +#ifndef __STATIC_INLINE + #define __STATIC_INLINE static __inline +#endif +#ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE __attribute__((always_inline)) static __inline +#endif +#ifndef __NO_RETURN + #define __NO_RETURN __attribute__((__noreturn__)) +#endif +#ifndef __USED + #define __USED __attribute__((used)) +#endif +#ifndef __WEAK + #define __WEAK __attribute__((weak)) +#endif +#ifndef __PACKED + #define __PACKED __attribute__((packed, aligned(1))) +#endif +#ifndef __PACKED_STRUCT + #define __PACKED_STRUCT struct __attribute__((packed, aligned(1))) +#endif +#ifndef __PACKED_UNION + #define __PACKED_UNION union __attribute__((packed, aligned(1))) +#endif +#ifndef __UNALIGNED_UINT32 /* deprecated */ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT32)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32 */ + struct __attribute__((packed)) T_UINT32 { uint32_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v) +#endif +#ifndef __UNALIGNED_UINT16_WRITE + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT16_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_WRITE */ + __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val)) +#endif +#ifndef __UNALIGNED_UINT16_READ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT16_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_READ */ + __PACKED_STRUCT T_UINT16_READ { uint16_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v) +#endif +#ifndef __UNALIGNED_UINT32_WRITE + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT32_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_WRITE */ + __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val)) +#endif +#ifndef __UNALIGNED_UINT32_READ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wpacked" +/*lint -esym(9058, T_UINT32_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_READ */ + __PACKED_STRUCT T_UINT32_READ { uint32_t v; }; + #pragma clang diagnostic pop + #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v) +#endif +#ifndef __ALIGNED + #define __ALIGNED(x) __attribute__((aligned(x))) +#endif +#ifndef __RESTRICT + #define __RESTRICT __restrict +#endif +#ifndef __COMPILER_BARRIER + #define __COMPILER_BARRIER() __ASM volatile("":::"memory") +#endif + +/* ######################### Startup and Lowlevel Init ######################## */ + +#ifndef __PROGRAM_START +#define __PROGRAM_START __main +#endif + +#ifndef __INITIAL_SP +#define __INITIAL_SP Image$$ARM_LIB_STACK$$ZI$$Limit +#endif + +#ifndef __STACK_LIMIT +#define __STACK_LIMIT Image$$ARM_LIB_STACK$$ZI$$Base +#endif + +#ifndef __VECTOR_TABLE +#define __VECTOR_TABLE __Vectors +#endif + +#ifndef __VECTOR_TABLE_ATTRIBUTE +#define __VECTOR_TABLE_ATTRIBUTE __attribute((used, section("RESET"))) +#endif + + +/* ########################### Core Function Access ########################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions + @{ + */ + +/** + \brief Enable IRQ Interrupts + \details Enables IRQ interrupts by clearing the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +/* intrinsic void __enable_irq(); see arm_compat.h */ + + +/** + \brief Disable IRQ Interrupts + \details Disables IRQ interrupts by setting the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +/* intrinsic void __disable_irq(); see arm_compat.h */ + + +/** + \brief Get Control Register + \details Returns the content of the Control Register. + \return Control Register value + */ +__STATIC_FORCEINLINE uint32_t __get_CONTROL(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Control Register (non-secure) + \details Returns the content of the non-secure Control Register when in secure mode. + \return non-secure Control Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Control Register + \details Writes the given value to the Control Register. + \param [in] control Control Register value to set + */ +__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control) +{ + __ASM volatile ("MSR control, %0" : : "r" (control) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Control Register (non-secure) + \details Writes the given value to the non-secure Control Register when in secure state. + \param [in] control Control Register value to set + */ +__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control) +{ + __ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory"); +} +#endif + + +/** + \brief Get IPSR Register + \details Returns the content of the IPSR Register. + \return IPSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_IPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, ipsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get APSR Register + \details Returns the content of the APSR Register. + \return APSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_APSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, apsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get xPSR Register + \details Returns the content of the xPSR Register. + \return xPSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_xPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, xpsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get Process Stack Pointer + \details Returns the current value of the Process Stack Pointer (PSP). + \return PSP Register value + */ +__STATIC_FORCEINLINE uint32_t __get_PSP(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, psp" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Process Stack Pointer (non-secure) + \details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state. + \return PSP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, psp_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Process Stack Pointer + \details Assigns the given value to the Process Stack Pointer (PSP). + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : ); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Process Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state. + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : ); +} +#endif + + +/** + \brief Get Main Stack Pointer + \details Returns the current value of the Main Stack Pointer (MSP). + \return MSP Register value + */ +__STATIC_FORCEINLINE uint32_t __get_MSP(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, msp" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Main Stack Pointer (non-secure) + \details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state. + \return MSP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, msp_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Main Stack Pointer + \details Assigns the given value to the Main Stack Pointer (MSP). + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : ); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Main Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state. + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : ); +} +#endif + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Stack Pointer (non-secure) + \details Returns the current value of the non-secure Stack Pointer (SP) when in secure state. + \return SP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, sp_ns" : "=r" (result) ); + return(result); +} + + +/** + \brief Set Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state. + \param [in] topOfStack Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack) +{ + __ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : ); +} +#endif + + +/** + \brief Get Priority Mask + \details Returns the current state of the priority mask bit from the Priority Mask Register. + \return Priority Mask value + */ +__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Priority Mask (non-secure) + \details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state. + \return Priority Mask value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Priority Mask + \details Assigns the given value to the Priority Mask Register. + \param [in] priMask Priority Mask + */ +__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask) +{ + __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Priority Mask (non-secure) + \details Assigns the given value to the non-secure Priority Mask Register when in secure state. + \param [in] priMask Priority Mask + */ +__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask) +{ + __ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory"); +} +#endif + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) +/** + \brief Enable FIQ + \details Enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __enable_fault_irq __enable_fiq /* see arm_compat.h */ + + +/** + \brief Disable FIQ + \details Disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __disable_fault_irq __disable_fiq /* see arm_compat.h */ + + +/** + \brief Get Base Priority + \details Returns the current value of the Base Priority register. + \return Base Priority register value + */ +__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Base Priority (non-secure) + \details Returns the current value of the non-secure Base Priority register when in secure state. + \return Base Priority register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Base Priority + \details Assigns the given value to the Base Priority register. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri) +{ + __ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Base Priority (non-secure) + \details Assigns the given value to the non-secure Base Priority register when in secure state. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri) +{ + __ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory"); +} +#endif + + +/** + \brief Set Base Priority with condition + \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled, + or the new value increases the BASEPRI priority level. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri) +{ + __ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory"); +} + + +/** + \brief Get Fault Mask + \details Returns the current value of the Fault Mask register. + \return Fault Mask register value + */ +__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Fault Mask (non-secure) + \details Returns the current value of the non-secure Fault Mask register when in secure state. + \return Fault Mask register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Fault Mask + \details Assigns the given value to the Fault Mask register. + \param [in] faultMask Fault Mask value to set + */ +__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Fault Mask (non-secure) + \details Assigns the given value to the non-secure Fault Mask register when in secure state. + \param [in] faultMask Fault Mask value to set + */ +__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory"); +} +#endif + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) + +/** + \brief Get Process Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always in non-secure + mode. + + \details Returns the current value of the Process Stack Pointer Limit (PSPLIM). + \return PSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, psplim" : "=r" (result) ); + return result; +#endif +} + +#if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Process Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always in non-secure + mode. + + \details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state. + \return PSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, psplim_ns" : "=r" (result) ); + return result; +#endif +} +#endif + + +/** + \brief Set Process Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored in non-secure + mode. + + \details Assigns the given value to the Process Stack Pointer Limit (PSPLIM). + \param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)ProcStackPtrLimit; +#else + __ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit)); +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Process Stack Pointer (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored in non-secure + mode. + + \details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state. + \param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)ProcStackPtrLimit; +#else + __ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit)); +#endif +} +#endif + + +/** + \brief Get Main Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always. + + \details Returns the current value of the Main Stack Pointer Limit (MSPLIM). + \return MSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, msplim" : "=r" (result) ); + return result; +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Main Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always. + + \details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state. + \return MSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, msplim_ns" : "=r" (result) ); + return result; +#endif +} +#endif + + +/** + \brief Set Main Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored. + + \details Assigns the given value to the Main Stack Pointer Limit (MSPLIM). + \param [in] MainStackPtrLimit Main Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + (void)MainStackPtrLimit; +#else + __ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit)); +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Main Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored. + + \details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state. + \param [in] MainStackPtrLimit Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + (void)MainStackPtrLimit; +#else + __ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit)); +#endif +} +#endif + +#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + +/** + \brief Get FPSCR + \details Returns the current value of the Floating Point Status/Control register. + \return Floating Point Status/Control register value + */ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) +#define __get_FPSCR (uint32_t)__builtin_arm_get_fpscr +#else +#define __get_FPSCR() ((uint32_t)0U) +#endif + +/** + \brief Set FPSCR + \details Assigns the given value to the Floating Point Status/Control register. + \param [in] fpscr Floating Point Status/Control value to set + */ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) +#define __set_FPSCR __builtin_arm_set_fpscr +#else +#define __set_FPSCR(x) ((void)(x)) +#endif + + +/*@} end of CMSIS_Core_RegAccFunctions */ + + +/* ########################## Core Instruction Access ######################### */ +/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface + Access to dedicated instructions + @{ +*/ + +/* Define macros for porting to both thumb1 and thumb2. + * For thumb1, use low register (r0-r7), specified by constraint "l" + * Otherwise, use general registers, specified by constraint "r" */ +#if defined (__thumb__) && !defined (__thumb2__) +#define __CMSIS_GCC_OUT_REG(r) "=l" (r) +#define __CMSIS_GCC_USE_REG(r) "l" (r) +#else +#define __CMSIS_GCC_OUT_REG(r) "=r" (r) +#define __CMSIS_GCC_USE_REG(r) "r" (r) +#endif + +/** + \brief No Operation + \details No Operation does nothing. This instruction can be used for code alignment purposes. + */ +#define __NOP __builtin_arm_nop + +/** + \brief Wait For Interrupt + \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs. + */ +#define __WFI __builtin_arm_wfi + + +/** + \brief Wait For Event + \details Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +#define __WFE __builtin_arm_wfe + + +/** + \brief Send Event + \details Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +#define __SEV __builtin_arm_sev + + +/** + \brief Instruction Synchronization Barrier + \details Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or memory, + after the instruction has been completed. + */ +#define __ISB() __builtin_arm_isb(0xF) + +/** + \brief Data Synchronization Barrier + \details Acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +#define __DSB() __builtin_arm_dsb(0xF) + + +/** + \brief Data Memory Barrier + \details Ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +#define __DMB() __builtin_arm_dmb(0xF) + + +/** + \brief Reverse byte order (32 bit) + \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412. + \param [in] value Value to reverse + \return Reversed value + */ +#define __REV(value) __builtin_bswap32(value) + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856. + \param [in] value Value to reverse + \return Reversed value + */ +#define __REV16(value) __ROR(__REV(value), 16) + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000. + \param [in] value Value to reverse + \return Reversed value + */ +#define __REVSH(value) (int16_t)__builtin_bswap16(value) + + +/** + \brief Rotate Right in unsigned value (32 bit) + \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + \param [in] op1 Value to rotate + \param [in] op2 Number of Bits to rotate + \return Rotated value + */ +__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2) +{ + op2 %= 32U; + if (op2 == 0U) + { + return op1; + } + return (op1 >> op2) | (op1 << (32U - op2)); +} + + +/** + \brief Breakpoint + \details Causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __ASM volatile ("bkpt "#value) + + +/** + \brief Reverse bit order of value + \details Reverses the bit order of the given value. + \param [in] value Value to reverse + \return Reversed value + */ +#define __RBIT __builtin_arm_rbit + +/** + \brief Count leading zeros + \details Counts the number of leading zeros of a data value. + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +__STATIC_FORCEINLINE uint8_t __CLZ(uint32_t value) +{ + /* Even though __builtin_clz produces a CLZ instruction on ARM, formally + __builtin_clz(0) is undefined behaviour, so handle this case specially. + This guarantees ARM-compatible results if happening to compile on a non-ARM + target, and ensures the compiler doesn't decide to activate any + optimisations using the logic "value was passed to __builtin_clz, so it + is non-zero". + ARM Compiler 6.10 and possibly earlier will optimise this test away, leaving a + single CLZ instruction. + */ + if (value == 0U) + { + return 32U; + } + return __builtin_clz(value); +} + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) +/** + \brief LDR Exclusive (8 bit) + \details Executes a exclusive LDR instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#define __LDREXB (uint8_t)__builtin_arm_ldrex + + +/** + \brief LDR Exclusive (16 bit) + \details Executes a exclusive LDR instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#define __LDREXH (uint16_t)__builtin_arm_ldrex + + +/** + \brief LDR Exclusive (32 bit) + \details Executes a exclusive LDR instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#define __LDREXW (uint32_t)__builtin_arm_ldrex + + +/** + \brief STR Exclusive (8 bit) + \details Executes a exclusive STR instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXB (uint32_t)__builtin_arm_strex + + +/** + \brief STR Exclusive (16 bit) + \details Executes a exclusive STR instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXH (uint32_t)__builtin_arm_strex + + +/** + \brief STR Exclusive (32 bit) + \details Executes a exclusive STR instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXW (uint32_t)__builtin_arm_strex + + +/** + \brief Remove the exclusive lock + \details Removes the exclusive lock which is created by LDREX. + */ +#define __CLREX __builtin_arm_clrex + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) + +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT __builtin_arm_ssat + + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT __builtin_arm_usat + + +/** + \brief Rotate Right with Extend (32 bit) + \details Moves each bit of a bitstring right by one bit. + The carry input is shifted in at the left end of the bitstring. + \param [in] value Value to rotate + \return Rotated value + */ +__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rrx %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +} + + +/** + \brief LDRT Unprivileged (8 bit) + \details Executes a Unprivileged LDRT instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint8_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDRT Unprivileged (16 bit) + \details Executes a Unprivileged LDRT instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint16_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDRT Unprivileged (32 bit) + \details Executes a Unprivileged LDRT instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) ); + return(result); +} + + +/** + \brief STRT Unprivileged (8 bit) + \details Executes a Unprivileged STRT instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr) +{ + __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief STRT Unprivileged (16 bit) + \details Executes a Unprivileged STRT instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr) +{ + __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief STRT Unprivileged (32 bit) + \details Executes a Unprivileged STRT instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr) +{ + __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) ); +} + +#else /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat) +{ + if ((sat >= 1U) && (sat <= 32U)) + { + const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U); + const int32_t min = -1 - max ; + if (val > max) + { + return max; + } + else if (val < min) + { + return min; + } + } + return val; +} + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat) +{ + if (sat <= 31U) + { + const uint32_t max = ((1U << sat) - 1U); + if (val > (int32_t)max) + { + return max; + } + else if (val < 0) + { + return 0U; + } + } + return (uint32_t)val; +} + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) +/** + \brief Load-Acquire (8 bit) + \details Executes a LDAB instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint8_t) result); +} + + +/** + \brief Load-Acquire (16 bit) + \details Executes a LDAH instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint16_t) result); +} + + +/** + \brief Load-Acquire (32 bit) + \details Executes a LDA instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) ); + return(result); +} + + +/** + \brief Store-Release (8 bit) + \details Executes a STLB instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr) +{ + __ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Store-Release (16 bit) + \details Executes a STLH instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr) +{ + __ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Store-Release (32 bit) + \details Executes a STL instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr) +{ + __ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Load-Acquire Exclusive (8 bit) + \details Executes a LDAB exclusive instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#define __LDAEXB (uint8_t)__builtin_arm_ldaex + + +/** + \brief Load-Acquire Exclusive (16 bit) + \details Executes a LDAH exclusive instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#define __LDAEXH (uint16_t)__builtin_arm_ldaex + + +/** + \brief Load-Acquire Exclusive (32 bit) + \details Executes a LDA exclusive instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#define __LDAEX (uint32_t)__builtin_arm_ldaex + + +/** + \brief Store-Release Exclusive (8 bit) + \details Executes a STLB exclusive instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STLEXB (uint32_t)__builtin_arm_stlex + + +/** + \brief Store-Release Exclusive (16 bit) + \details Executes a STLH exclusive instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STLEXH (uint32_t)__builtin_arm_stlex + + +/** + \brief Store-Release Exclusive (32 bit) + \details Executes a STL exclusive instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STLEX (uint32_t)__builtin_arm_stlex + +#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + +/*@}*/ /* end of group CMSIS_Core_InstructionInterface */ + + +/* ################### Compiler specific Intrinsics ########################### */ +/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics + Access to dedicated SIMD instructions + @{ +*/ + +#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1)) + +__STATIC_FORCEINLINE uint32_t __SADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + + +__STATIC_FORCEINLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("ssub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + + +__STATIC_FORCEINLINE uint32_t __SADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("ssub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("ssax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USAD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usad8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("usada8 %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +#define __SSAT16(ARG1,ARG2) \ +({ \ + int32_t __RES, __ARG1 = (ARG1); \ + __ASM ("ssat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + +#define __USAT16(ARG1,ARG2) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1); \ + __ASM ("usat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + +__STATIC_FORCEINLINE uint32_t __UXTB16(uint32_t op1) +{ + uint32_t result; + + __ASM volatile ("uxtb16 %0, %1" : "=r" (result) : "r" (op1)); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SXTB16(uint32_t op1) +{ + uint32_t result; + + __ASM volatile ("sxtb16 %0, %1" : "=r" (result) : "r" (op1)); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMUAD (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smuad %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smuadx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smlad %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smladx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint32_t __SMUSD (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smusd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smusdx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smlsd %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smlsdx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint32_t __SEL (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sel %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE int32_t __QADD( int32_t op1, int32_t op2) +{ + int32_t result; + + __ASM volatile ("qadd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE int32_t __QSUB( int32_t op1, int32_t op2) +{ + int32_t result; + + __ASM volatile ("qsub %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +#define __PKHBT(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) | \ + ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) ) + +#define __PKHTB(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0xFFFF0000UL) | \ + ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL) ) + +__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3) +{ + int32_t result; + + __ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +#endif /* (__ARM_FEATURE_DSP == 1) */ +/*@} end of group CMSIS_SIMD_intrinsics */ + + +#endif /* __CMSIS_ARMCLANG_H */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_compiler.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_compiler.h new file mode 100644 index 0000000000..adbf296f15 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_compiler.h @@ -0,0 +1,283 @@ +/**************************************************************************//** + * @file cmsis_compiler.h + * @brief CMSIS compiler generic header file + * @version V5.1.0 + * @date 09. October 2018 + ******************************************************************************/ +/* + * Copyright (c) 2009-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CMSIS_COMPILER_H +#define __CMSIS_COMPILER_H + +#include + +/* + * Arm Compiler 4/5 + */ +#if defined ( __CC_ARM ) + #include "cmsis_armcc.h" + + +/* + * Arm Compiler 6.6 LTM (armclang) + */ +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) && (__ARMCC_VERSION < 6100100) + #include "cmsis_armclang_ltm.h" + + /* + * Arm Compiler above 6.10.1 (armclang) + */ +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6100100) + #include "cmsis_armclang.h" + + +/* + * GNU Compiler + */ +#elif defined ( __GNUC__ ) + #include "cmsis_gcc.h" + + +/* + * IAR Compiler + */ +#elif defined ( __ICCARM__ ) + #include + + +/* + * TI Arm Compiler + */ +#elif defined ( __TI_ARM__ ) + #include + + #ifndef __ASM + #define __ASM __asm + #endif + #ifndef __INLINE + #define __INLINE inline + #endif + #ifndef __STATIC_INLINE + #define __STATIC_INLINE static inline + #endif + #ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE __STATIC_INLINE + #endif + #ifndef __NO_RETURN + #define __NO_RETURN __attribute__((noreturn)) + #endif + #ifndef __USED + #define __USED __attribute__((used)) + #endif + #ifndef __WEAK + #define __WEAK __attribute__((weak)) + #endif + #ifndef __PACKED + #define __PACKED __attribute__((packed)) + #endif + #ifndef __PACKED_STRUCT + #define __PACKED_STRUCT struct __attribute__((packed)) + #endif + #ifndef __PACKED_UNION + #define __PACKED_UNION union __attribute__((packed)) + #endif + #ifndef __UNALIGNED_UINT32 /* deprecated */ + struct __attribute__((packed)) T_UINT32 { uint32_t v; }; + #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v) + #endif + #ifndef __UNALIGNED_UINT16_WRITE + __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; }; + #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void*)(addr))->v) = (val)) + #endif + #ifndef __UNALIGNED_UINT16_READ + __PACKED_STRUCT T_UINT16_READ { uint16_t v; }; + #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v) + #endif + #ifndef __UNALIGNED_UINT32_WRITE + __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; }; + #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val)) + #endif + #ifndef __UNALIGNED_UINT32_READ + __PACKED_STRUCT T_UINT32_READ { uint32_t v; }; + #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v) + #endif + #ifndef __ALIGNED + #define __ALIGNED(x) __attribute__((aligned(x))) + #endif + #ifndef __RESTRICT + #define __RESTRICT __restrict + #endif + #ifndef __COMPILER_BARRIER + #warning No compiler specific solution for __COMPILER_BARRIER. __COMPILER_BARRIER is ignored. + #define __COMPILER_BARRIER() (void)0 + #endif + + +/* + * TASKING Compiler + */ +#elif defined ( __TASKING__ ) + /* + * The CMSIS functions have been implemented as intrinsics in the compiler. + * Please use "carm -?i" to get an up to date list of all intrinsics, + * Including the CMSIS ones. + */ + + #ifndef __ASM + #define __ASM __asm + #endif + #ifndef __INLINE + #define __INLINE inline + #endif + #ifndef __STATIC_INLINE + #define __STATIC_INLINE static inline + #endif + #ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE __STATIC_INLINE + #endif + #ifndef __NO_RETURN + #define __NO_RETURN __attribute__((noreturn)) + #endif + #ifndef __USED + #define __USED __attribute__((used)) + #endif + #ifndef __WEAK + #define __WEAK __attribute__((weak)) + #endif + #ifndef __PACKED + #define __PACKED __packed__ + #endif + #ifndef __PACKED_STRUCT + #define __PACKED_STRUCT struct __packed__ + #endif + #ifndef __PACKED_UNION + #define __PACKED_UNION union __packed__ + #endif + #ifndef __UNALIGNED_UINT32 /* deprecated */ + struct __packed__ T_UINT32 { uint32_t v; }; + #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v) + #endif + #ifndef __UNALIGNED_UINT16_WRITE + __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; }; + #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val)) + #endif + #ifndef __UNALIGNED_UINT16_READ + __PACKED_STRUCT T_UINT16_READ { uint16_t v; }; + #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v) + #endif + #ifndef __UNALIGNED_UINT32_WRITE + __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; }; + #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val)) + #endif + #ifndef __UNALIGNED_UINT32_READ + __PACKED_STRUCT T_UINT32_READ { uint32_t v; }; + #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v) + #endif + #ifndef __ALIGNED + #define __ALIGNED(x) __align(x) + #endif + #ifndef __RESTRICT + #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored. + #define __RESTRICT + #endif + #ifndef __COMPILER_BARRIER + #warning No compiler specific solution for __COMPILER_BARRIER. __COMPILER_BARRIER is ignored. + #define __COMPILER_BARRIER() (void)0 + #endif + + +/* + * COSMIC Compiler + */ +#elif defined ( __CSMC__ ) + #include + + #ifndef __ASM + #define __ASM _asm + #endif + #ifndef __INLINE + #define __INLINE inline + #endif + #ifndef __STATIC_INLINE + #define __STATIC_INLINE static inline + #endif + #ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE __STATIC_INLINE + #endif + #ifndef __NO_RETURN + // NO RETURN is automatically detected hence no warning here + #define __NO_RETURN + #endif + #ifndef __USED + #warning No compiler specific solution for __USED. __USED is ignored. + #define __USED + #endif + #ifndef __WEAK + #define __WEAK __weak + #endif + #ifndef __PACKED + #define __PACKED @packed + #endif + #ifndef __PACKED_STRUCT + #define __PACKED_STRUCT @packed struct + #endif + #ifndef __PACKED_UNION + #define __PACKED_UNION @packed union + #endif + #ifndef __UNALIGNED_UINT32 /* deprecated */ + @packed struct T_UINT32 { uint32_t v; }; + #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v) + #endif + #ifndef __UNALIGNED_UINT16_WRITE + __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; }; + #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val)) + #endif + #ifndef __UNALIGNED_UINT16_READ + __PACKED_STRUCT T_UINT16_READ { uint16_t v; }; + #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v) + #endif + #ifndef __UNALIGNED_UINT32_WRITE + __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; }; + #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val)) + #endif + #ifndef __UNALIGNED_UINT32_READ + __PACKED_STRUCT T_UINT32_READ { uint32_t v; }; + #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v) + #endif + #ifndef __ALIGNED + #warning No compiler specific solution for __ALIGNED. __ALIGNED is ignored. + #define __ALIGNED(x) + #endif + #ifndef __RESTRICT + #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored. + #define __RESTRICT + #endif + #ifndef __COMPILER_BARRIER + #warning No compiler specific solution for __COMPILER_BARRIER. __COMPILER_BARRIER is ignored. + #define __COMPILER_BARRIER() (void)0 + #endif + + +#else + #error Unknown compiler. +#endif + + +#endif /* __CMSIS_COMPILER_H */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_gcc.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_gcc.h new file mode 100644 index 0000000000..3ddcc58b69 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_gcc.h @@ -0,0 +1,2168 @@ +/**************************************************************************//** + * @file cmsis_gcc.h + * @brief CMSIS compiler GCC header file + * @version V5.2.0 + * @date 08. May 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CMSIS_GCC_H +#define __CMSIS_GCC_H + +/* ignore some GCC warnings */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wsign-conversion" +#pragma GCC diagnostic ignored "-Wconversion" +#pragma GCC diagnostic ignored "-Wunused-parameter" + +/* Fallback for __has_builtin */ +#ifndef __has_builtin + #define __has_builtin(x) (0) +#endif + +/* CMSIS compiler specific defines */ +#ifndef __ASM + #define __ASM __asm +#endif +#ifndef __INLINE + #define __INLINE inline +#endif +#ifndef __STATIC_INLINE + #define __STATIC_INLINE static inline +#endif +#ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE __attribute__((always_inline)) static inline +#endif +#ifndef __NO_RETURN + #define __NO_RETURN __attribute__((__noreturn__)) +#endif +#ifndef __USED + #define __USED __attribute__((used)) +#endif +#ifndef __WEAK + #define __WEAK __attribute__((weak)) +#endif +#ifndef __PACKED + #define __PACKED __attribute__((packed, aligned(1))) +#endif +#ifndef __PACKED_STRUCT + #define __PACKED_STRUCT struct __attribute__((packed, aligned(1))) +#endif +#ifndef __PACKED_UNION + #define __PACKED_UNION union __attribute__((packed, aligned(1))) +#endif +#ifndef __UNALIGNED_UINT32 /* deprecated */ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wpacked" + #pragma GCC diagnostic ignored "-Wattributes" + struct __attribute__((packed)) T_UINT32 { uint32_t v; }; + #pragma GCC diagnostic pop + #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v) +#endif +#ifndef __UNALIGNED_UINT16_WRITE + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wpacked" + #pragma GCC diagnostic ignored "-Wattributes" + __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; }; + #pragma GCC diagnostic pop + #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val)) +#endif +#ifndef __UNALIGNED_UINT16_READ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wpacked" + #pragma GCC diagnostic ignored "-Wattributes" + __PACKED_STRUCT T_UINT16_READ { uint16_t v; }; + #pragma GCC diagnostic pop + #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v) +#endif +#ifndef __UNALIGNED_UINT32_WRITE + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wpacked" + #pragma GCC diagnostic ignored "-Wattributes" + __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; }; + #pragma GCC diagnostic pop + #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val)) +#endif +#ifndef __UNALIGNED_UINT32_READ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wpacked" + #pragma GCC diagnostic ignored "-Wattributes" + __PACKED_STRUCT T_UINT32_READ { uint32_t v; }; + #pragma GCC diagnostic pop + #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v) +#endif +#ifndef __ALIGNED + #define __ALIGNED(x) __attribute__((aligned(x))) +#endif +#ifndef __RESTRICT + #define __RESTRICT __restrict +#endif +#ifndef __COMPILER_BARRIER + #define __COMPILER_BARRIER() __ASM volatile("":::"memory") +#endif + +/* ######################### Startup and Lowlevel Init ######################## */ + +#ifndef __PROGRAM_START + +/** + \brief Initializes data and bss sections + \details This default implementations initialized all data and additional bss + sections relying on .copy.table and .zero.table specified properly + in the used linker script. + + */ +__STATIC_FORCEINLINE __NO_RETURN void __cmsis_start(void) +{ + extern void _start(void) __NO_RETURN; + + typedef struct { + uint32_t const* src; + uint32_t* dest; + uint32_t wlen; + } __copy_table_t; + + typedef struct { + uint32_t* dest; + uint32_t wlen; + } __zero_table_t; + + extern const __copy_table_t __copy_table_start__; + extern const __copy_table_t __copy_table_end__; + extern const __zero_table_t __zero_table_start__; + extern const __zero_table_t __zero_table_end__; + + for (__copy_table_t const* pTable = &__copy_table_start__; pTable < &__copy_table_end__; ++pTable) { + for(uint32_t i=0u; iwlen; ++i) { + pTable->dest[i] = pTable->src[i]; + } + } + + for (__zero_table_t const* pTable = &__zero_table_start__; pTable < &__zero_table_end__; ++pTable) { + for(uint32_t i=0u; iwlen; ++i) { + pTable->dest[i] = 0u; + } + } + + _start(); +} + +#define __PROGRAM_START __cmsis_start +#endif + +#ifndef __INITIAL_SP +#define __INITIAL_SP __StackTop +#endif + +#ifndef __STACK_LIMIT +#define __STACK_LIMIT __StackLimit +#endif + +#ifndef __VECTOR_TABLE +#define __VECTOR_TABLE __Vectors +#endif + +#ifndef __VECTOR_TABLE_ATTRIBUTE +#define __VECTOR_TABLE_ATTRIBUTE __attribute((used, section(".vectors"))) +#endif + +/* ########################### Core Function Access ########################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions + @{ + */ + +/** + \brief Enable IRQ Interrupts + \details Enables IRQ interrupts by clearing the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__STATIC_FORCEINLINE void __enable_irq(void) +{ + __ASM volatile ("cpsie i" : : : "memory"); +} + + +/** + \brief Disable IRQ Interrupts + \details Disables IRQ interrupts by setting the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__STATIC_FORCEINLINE void __disable_irq(void) +{ + __ASM volatile ("cpsid i" : : : "memory"); +} + + +/** + \brief Get Control Register + \details Returns the content of the Control Register. + \return Control Register value + */ +__STATIC_FORCEINLINE uint32_t __get_CONTROL(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Control Register (non-secure) + \details Returns the content of the non-secure Control Register when in secure mode. + \return non-secure Control Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Control Register + \details Writes the given value to the Control Register. + \param [in] control Control Register value to set + */ +__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control) +{ + __ASM volatile ("MSR control, %0" : : "r" (control) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Control Register (non-secure) + \details Writes the given value to the non-secure Control Register when in secure state. + \param [in] control Control Register value to set + */ +__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control) +{ + __ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory"); +} +#endif + + +/** + \brief Get IPSR Register + \details Returns the content of the IPSR Register. + \return IPSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_IPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, ipsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get APSR Register + \details Returns the content of the APSR Register. + \return APSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_APSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, apsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get xPSR Register + \details Returns the content of the xPSR Register. + \return xPSR Register value + */ +__STATIC_FORCEINLINE uint32_t __get_xPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, xpsr" : "=r" (result) ); + return(result); +} + + +/** + \brief Get Process Stack Pointer + \details Returns the current value of the Process Stack Pointer (PSP). + \return PSP Register value + */ +__STATIC_FORCEINLINE uint32_t __get_PSP(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, psp" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Process Stack Pointer (non-secure) + \details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state. + \return PSP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, psp_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Process Stack Pointer + \details Assigns the given value to the Process Stack Pointer (PSP). + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : ); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Process Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state. + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : ); +} +#endif + + +/** + \brief Get Main Stack Pointer + \details Returns the current value of the Main Stack Pointer (MSP). + \return MSP Register value + */ +__STATIC_FORCEINLINE uint32_t __get_MSP(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, msp" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Main Stack Pointer (non-secure) + \details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state. + \return MSP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, msp_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Main Stack Pointer + \details Assigns the given value to the Main Stack Pointer (MSP). + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : ); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Main Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state. + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : ); +} +#endif + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Stack Pointer (non-secure) + \details Returns the current value of the non-secure Stack Pointer (SP) when in secure state. + \return SP Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, sp_ns" : "=r" (result) ); + return(result); +} + + +/** + \brief Set Stack Pointer (non-secure) + \details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state. + \param [in] topOfStack Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack) +{ + __ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : ); +} +#endif + + +/** + \brief Get Priority Mask + \details Returns the current state of the priority mask bit from the Priority Mask Register. + \return Priority Mask value + */ +__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask" : "=r" (result) :: "memory"); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Priority Mask (non-secure) + \details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state. + \return Priority Mask value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask_ns" : "=r" (result) :: "memory"); + return(result); +} +#endif + + +/** + \brief Set Priority Mask + \details Assigns the given value to the Priority Mask Register. + \param [in] priMask Priority Mask + */ +__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask) +{ + __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Priority Mask (non-secure) + \details Assigns the given value to the non-secure Priority Mask Register when in secure state. + \param [in] priMask Priority Mask + */ +__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask) +{ + __ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory"); +} +#endif + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) +/** + \brief Enable FIQ + \details Enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__STATIC_FORCEINLINE void __enable_fault_irq(void) +{ + __ASM volatile ("cpsie f" : : : "memory"); +} + + +/** + \brief Disable FIQ + \details Disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__STATIC_FORCEINLINE void __disable_fault_irq(void) +{ + __ASM volatile ("cpsid f" : : : "memory"); +} + + +/** + \brief Get Base Priority + \details Returns the current value of the Base Priority register. + \return Base Priority register value + */ +__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Base Priority (non-secure) + \details Returns the current value of the non-secure Base Priority register when in secure state. + \return Base Priority register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Base Priority + \details Assigns the given value to the Base Priority register. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri) +{ + __ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Base Priority (non-secure) + \details Assigns the given value to the non-secure Base Priority register when in secure state. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri) +{ + __ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory"); +} +#endif + + +/** + \brief Set Base Priority with condition + \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled, + or the new value increases the BASEPRI priority level. + \param [in] basePri Base Priority value to set + */ +__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri) +{ + __ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory"); +} + + +/** + \brief Get Fault Mask + \details Returns the current value of the Fault Mask register. + \return Fault Mask register value + */ +__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask" : "=r" (result) ); + return(result); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Fault Mask (non-secure) + \details Returns the current value of the non-secure Fault Mask register when in secure state. + \return Fault Mask register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask_ns" : "=r" (result) ); + return(result); +} +#endif + + +/** + \brief Set Fault Mask + \details Assigns the given value to the Fault Mask register. + \param [in] faultMask Fault Mask value to set + */ +__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory"); +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Fault Mask (non-secure) + \details Assigns the given value to the non-secure Fault Mask register when in secure state. + \param [in] faultMask Fault Mask value to set + */ +__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory"); +} +#endif + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) + +/** + \brief Get Process Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always in non-secure + mode. + + \details Returns the current value of the Process Stack Pointer Limit (PSPLIM). + \return PSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, psplim" : "=r" (result) ); + return result; +#endif +} + +#if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Process Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always. + + \details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state. + \return PSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, psplim_ns" : "=r" (result) ); + return result; +#endif +} +#endif + + +/** + \brief Set Process Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored in non-secure + mode. + + \details Assigns the given value to the Process Stack Pointer Limit (PSPLIM). + \param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)ProcStackPtrLimit; +#else + __ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit)); +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Process Stack Pointer (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored. + + \details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state. + \param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)ProcStackPtrLimit; +#else + __ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit)); +#endif +} +#endif + + +/** + \brief Get Main Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always in non-secure + mode. + + \details Returns the current value of the Main Stack Pointer Limit (MSPLIM). + \return MSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, msplim" : "=r" (result) ); + return result; +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Get Main Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence zero is returned always. + + \details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state. + \return MSPLIM Register value + */ +__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + return 0U; +#else + uint32_t result; + __ASM volatile ("MRS %0, msplim_ns" : "=r" (result) ); + return result; +#endif +} +#endif + + +/** + \brief Set Main Stack Pointer Limit + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored in non-secure + mode. + + \details Assigns the given value to the Main Stack Pointer Limit (MSPLIM). + \param [in] MainStackPtrLimit Main Stack Pointer Limit value to set + */ +__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + (void)MainStackPtrLimit; +#else + __ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit)); +#endif +} + + +#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) +/** + \brief Set Main Stack Pointer Limit (non-secure) + Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure + Stack Pointer Limit register hence the write is silently ignored. + + \details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state. + \param [in] MainStackPtrLimit Main Stack Pointer value to set + */ +__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit) +{ +#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + (void)MainStackPtrLimit; +#else + __ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit)); +#endif +} +#endif + +#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + + +/** + \brief Get FPSCR + \details Returns the current value of the Floating Point Status/Control register. + \return Floating Point Status/Control register value + */ +__STATIC_FORCEINLINE uint32_t __get_FPSCR(void) +{ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) +#if __has_builtin(__builtin_arm_get_fpscr) +// Re-enable using built-in when GCC has been fixed +// || (__GNUC__ > 7) || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2) + /* see https://gcc.gnu.org/ml/gcc-patches/2017-04/msg00443.html */ + return __builtin_arm_get_fpscr(); +#else + uint32_t result; + + __ASM volatile ("VMRS %0, fpscr" : "=r" (result) ); + return(result); +#endif +#else + return(0U); +#endif +} + + +/** + \brief Set FPSCR + \details Assigns the given value to the Floating Point Status/Control register. + \param [in] fpscr Floating Point Status/Control value to set + */ +__STATIC_FORCEINLINE void __set_FPSCR(uint32_t fpscr) +{ +#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) +#if __has_builtin(__builtin_arm_set_fpscr) +// Re-enable using built-in when GCC has been fixed +// || (__GNUC__ > 7) || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2) + /* see https://gcc.gnu.org/ml/gcc-patches/2017-04/msg00443.html */ + __builtin_arm_set_fpscr(fpscr); +#else + __ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc", "memory"); +#endif +#else + (void)fpscr; +#endif +} + + +/*@} end of CMSIS_Core_RegAccFunctions */ + + +/* ########################## Core Instruction Access ######################### */ +/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface + Access to dedicated instructions + @{ +*/ + +/* Define macros for porting to both thumb1 and thumb2. + * For thumb1, use low register (r0-r7), specified by constraint "l" + * Otherwise, use general registers, specified by constraint "r" */ +#if defined (__thumb__) && !defined (__thumb2__) +#define __CMSIS_GCC_OUT_REG(r) "=l" (r) +#define __CMSIS_GCC_RW_REG(r) "+l" (r) +#define __CMSIS_GCC_USE_REG(r) "l" (r) +#else +#define __CMSIS_GCC_OUT_REG(r) "=r" (r) +#define __CMSIS_GCC_RW_REG(r) "+r" (r) +#define __CMSIS_GCC_USE_REG(r) "r" (r) +#endif + +/** + \brief No Operation + \details No Operation does nothing. This instruction can be used for code alignment purposes. + */ +#define __NOP() __ASM volatile ("nop") + +/** + \brief Wait For Interrupt + \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs. + */ +#define __WFI() __ASM volatile ("wfi") + + +/** + \brief Wait For Event + \details Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +#define __WFE() __ASM volatile ("wfe") + + +/** + \brief Send Event + \details Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +#define __SEV() __ASM volatile ("sev") + + +/** + \brief Instruction Synchronization Barrier + \details Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or memory, + after the instruction has been completed. + */ +__STATIC_FORCEINLINE void __ISB(void) +{ + __ASM volatile ("isb 0xF":::"memory"); +} + + +/** + \brief Data Synchronization Barrier + \details Acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +__STATIC_FORCEINLINE void __DSB(void) +{ + __ASM volatile ("dsb 0xF":::"memory"); +} + + +/** + \brief Data Memory Barrier + \details Ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +__STATIC_FORCEINLINE void __DMB(void) +{ + __ASM volatile ("dmb 0xF":::"memory"); +} + + +/** + \brief Reverse byte order (32 bit) + \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412. + \param [in] value Value to reverse + \return Reversed value + */ +__STATIC_FORCEINLINE uint32_t __REV(uint32_t value) +{ +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) + return __builtin_bswap32(value); +#else + uint32_t result; + + __ASM volatile ("rev %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return result; +#endif +} + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856. + \param [in] value Value to reverse + \return Reversed value + */ +__STATIC_FORCEINLINE uint32_t __REV16(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rev16 %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return result; +} + + +/** + \brief Reverse byte order (16 bit) + \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000. + \param [in] value Value to reverse + \return Reversed value + */ +__STATIC_FORCEINLINE int16_t __REVSH(int16_t value) +{ +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + return (int16_t)__builtin_bswap16(value); +#else + int16_t result; + + __ASM volatile ("revsh %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return result; +#endif +} + + +/** + \brief Rotate Right in unsigned value (32 bit) + \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + \param [in] op1 Value to rotate + \param [in] op2 Number of Bits to rotate + \return Rotated value + */ +__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2) +{ + op2 %= 32U; + if (op2 == 0U) + { + return op1; + } + return (op1 >> op2) | (op1 << (32U - op2)); +} + + +/** + \brief Breakpoint + \details Causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __ASM volatile ("bkpt "#value) + + +/** + \brief Reverse bit order of value + \details Reverses the bit order of the given value. + \param [in] value Value to reverse + \return Reversed value + */ +__STATIC_FORCEINLINE uint32_t __RBIT(uint32_t value) +{ + uint32_t result; + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) + __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) ); +#else + uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */ + + result = value; /* r will be reversed bits of v; first get LSB of v */ + for (value >>= 1U; value != 0U; value >>= 1U) + { + result <<= 1U; + result |= value & 1U; + s--; + } + result <<= s; /* shift when v's highest bits are zero */ +#endif + return result; +} + + +/** + \brief Count leading zeros + \details Counts the number of leading zeros of a data value. + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +__STATIC_FORCEINLINE uint8_t __CLZ(uint32_t value) +{ + /* Even though __builtin_clz produces a CLZ instruction on ARM, formally + __builtin_clz(0) is undefined behaviour, so handle this case specially. + This guarantees ARM-compatible results if happening to compile on a non-ARM + target, and ensures the compiler doesn't decide to activate any + optimisations using the logic "value was passed to __builtin_clz, so it + is non-zero". + ARM GCC 7.3 and possibly earlier will optimise this test away, leaving a + single CLZ instruction. + */ + if (value == 0U) + { + return 32U; + } + return __builtin_clz(value); +} + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) +/** + \brief LDR Exclusive (8 bit) + \details Executes a exclusive LDR instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDREXB(volatile uint8_t *addr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrexb %0, %1" : "=r" (result) : "Q" (*addr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrexb %0, [%1]" : "=r" (result) : "r" (addr) : "memory" ); +#endif + return ((uint8_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDR Exclusive (16 bit) + \details Executes a exclusive LDR instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDREXH(volatile uint16_t *addr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrexh %0, %1" : "=r" (result) : "Q" (*addr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrexh %0, [%1]" : "=r" (result) : "r" (addr) : "memory" ); +#endif + return ((uint16_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDR Exclusive (32 bit) + \details Executes a exclusive LDR instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDREXW(volatile uint32_t *addr) +{ + uint32_t result; + + __ASM volatile ("ldrex %0, %1" : "=r" (result) : "Q" (*addr) ); + return(result); +} + + +/** + \brief STR Exclusive (8 bit) + \details Executes a exclusive STR instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__STATIC_FORCEINLINE uint32_t __STREXB(uint8_t value, volatile uint8_t *addr) +{ + uint32_t result; + + __ASM volatile ("strexb %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" ((uint32_t)value) ); + return(result); +} + + +/** + \brief STR Exclusive (16 bit) + \details Executes a exclusive STR instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__STATIC_FORCEINLINE uint32_t __STREXH(uint16_t value, volatile uint16_t *addr) +{ + uint32_t result; + + __ASM volatile ("strexh %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" ((uint32_t)value) ); + return(result); +} + + +/** + \brief STR Exclusive (32 bit) + \details Executes a exclusive STR instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__STATIC_FORCEINLINE uint32_t __STREXW(uint32_t value, volatile uint32_t *addr) +{ + uint32_t result; + + __ASM volatile ("strex %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) ); + return(result); +} + + +/** + \brief Remove the exclusive lock + \details Removes the exclusive lock which is created by LDREX. + */ +__STATIC_FORCEINLINE void __CLREX(void) +{ + __ASM volatile ("clrex" ::: "memory"); +} + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] ARG1 Value to be saturated + \param [in] ARG2 Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT(ARG1,ARG2) \ +__extension__ \ +({ \ + int32_t __RES, __ARG1 = (ARG1); \ + __ASM ("ssat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] ARG1 Value to be saturated + \param [in] ARG2 Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT(ARG1,ARG2) \ + __extension__ \ +({ \ + uint32_t __RES, __ARG1 = (ARG1); \ + __ASM ("usat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + + +/** + \brief Rotate Right with Extend (32 bit) + \details Moves each bit of a bitstring right by one bit. + The carry input is shifted in at the left end of the bitstring. + \param [in] value Value to rotate + \return Rotated value + */ +__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rrx %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +} + + +/** + \brief LDRT Unprivileged (8 bit) + \details Executes a Unprivileged LDRT instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrbt %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" ); +#endif + return ((uint8_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDRT Unprivileged (16 bit) + \details Executes a Unprivileged LDRT instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrht %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" ); +#endif + return ((uint16_t) result); /* Add explicit type cast here */ +} + + +/** + \brief LDRT Unprivileged (32 bit) + \details Executes a Unprivileged LDRT instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) ); + return(result); +} + + +/** + \brief STRT Unprivileged (8 bit) + \details Executes a Unprivileged STRT instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr) +{ + __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief STRT Unprivileged (16 bit) + \details Executes a Unprivileged STRT instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr) +{ + __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief STRT Unprivileged (32 bit) + \details Executes a Unprivileged STRT instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr) +{ + __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) ); +} + +#else /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + +/** + \brief Signed Saturate + \details Saturates a signed value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat) +{ + if ((sat >= 1U) && (sat <= 32U)) + { + const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U); + const int32_t min = -1 - max ; + if (val > max) + { + return max; + } + else if (val < min) + { + return min; + } + } + return val; +} + +/** + \brief Unsigned Saturate + \details Saturates an unsigned value. + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat) +{ + if (sat <= 31U) + { + const uint32_t max = ((1U << sat) - 1U); + if (val > (int32_t)max) + { + return max; + } + else if (val < 0) + { + return 0U; + } + } + return (uint32_t)val; +} + +#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \ + (defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ + (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */ + + +#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) +/** + \brief Load-Acquire (8 bit) + \details Executes a LDAB instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint8_t) result); +} + + +/** + \brief Load-Acquire (16 bit) + \details Executes a LDAH instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint16_t) result); +} + + +/** + \brief Load-Acquire (32 bit) + \details Executes a LDA instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) ); + return(result); +} + + +/** + \brief Store-Release (8 bit) + \details Executes a STLB instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr) +{ + __ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Store-Release (16 bit) + \details Executes a STLH instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr) +{ + __ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Store-Release (32 bit) + \details Executes a STL instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + */ +__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr) +{ + __ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) ); +} + + +/** + \brief Load-Acquire Exclusive (8 bit) + \details Executes a LDAB exclusive instruction for 8 bit value. + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__STATIC_FORCEINLINE uint8_t __LDAEXB(volatile uint8_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldaexb %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint8_t) result); +} + + +/** + \brief Load-Acquire Exclusive (16 bit) + \details Executes a LDAH exclusive instruction for 16 bit values. + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__STATIC_FORCEINLINE uint16_t __LDAEXH(volatile uint16_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldaexh %0, %1" : "=r" (result) : "Q" (*ptr) ); + return ((uint16_t) result); +} + + +/** + \brief Load-Acquire Exclusive (32 bit) + \details Executes a LDA exclusive instruction for 32 bit values. + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__STATIC_FORCEINLINE uint32_t __LDAEX(volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("ldaex %0, %1" : "=r" (result) : "Q" (*ptr) ); + return(result); +} + + +/** + \brief Store-Release Exclusive (8 bit) + \details Executes a STLB exclusive instruction for 8 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__STATIC_FORCEINLINE uint32_t __STLEXB(uint8_t value, volatile uint8_t *ptr) +{ + uint32_t result; + + __ASM volatile ("stlexb %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) ); + return(result); +} + + +/** + \brief Store-Release Exclusive (16 bit) + \details Executes a STLH exclusive instruction for 16 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__STATIC_FORCEINLINE uint32_t __STLEXH(uint16_t value, volatile uint16_t *ptr) +{ + uint32_t result; + + __ASM volatile ("stlexh %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) ); + return(result); +} + + +/** + \brief Store-Release Exclusive (32 bit) + \details Executes a STL exclusive instruction for 32 bit values. + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__STATIC_FORCEINLINE uint32_t __STLEX(uint32_t value, volatile uint32_t *ptr) +{ + uint32_t result; + + __ASM volatile ("stlex %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) ); + return(result); +} + +#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */ + +/*@}*/ /* end of group CMSIS_Core_InstructionInterface */ + + +/* ################### Compiler specific Intrinsics ########################### */ +/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics + Access to dedicated SIMD instructions + @{ +*/ + +#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1)) + +__STATIC_FORCEINLINE uint32_t __SADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + + +__STATIC_FORCEINLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("ssub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + + +__STATIC_FORCEINLINE uint32_t __SADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("ssub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHASX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("ssax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __QSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("qsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("shsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uqsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uhsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USAD8(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("usad8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("usada8 %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +#define __SSAT16(ARG1,ARG2) \ +({ \ + int32_t __RES, __ARG1 = (ARG1); \ + __ASM ("ssat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + +#define __USAT16(ARG1,ARG2) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1); \ + __ASM ("usat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + +__STATIC_FORCEINLINE uint32_t __UXTB16(uint32_t op1) +{ + uint32_t result; + + __ASM volatile ("uxtb16 %0, %1" : "=r" (result) : "r" (op1)); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("uxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SXTB16(uint32_t op1) +{ + uint32_t result; + + __ASM volatile ("sxtb16 %0, %1" : "=r" (result) : "r" (op1)); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMUAD (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smuad %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smuadx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smlad %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smladx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint32_t __SMUSD (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smusd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("smusdx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smlsd %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3) +{ + uint32_t result; + + __ASM volatile ("smlsdx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +__STATIC_FORCEINLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc) +{ + union llreg_u{ + uint32_t w32[2]; + uint64_t w64; + } llr; + llr.w64 = acc; + +#ifndef __ARMEB__ /* Little endian */ + __ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) ); +#else /* Big endian */ + __ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) ); +#endif + + return(llr.w64); +} + +__STATIC_FORCEINLINE uint32_t __SEL (uint32_t op1, uint32_t op2) +{ + uint32_t result; + + __ASM volatile ("sel %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE int32_t __QADD( int32_t op1, int32_t op2) +{ + int32_t result; + + __ASM volatile ("qadd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +__STATIC_FORCEINLINE int32_t __QSUB( int32_t op1, int32_t op2) +{ + int32_t result; + + __ASM volatile ("qsub %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) ); + return(result); +} + +#if 0 +#define __PKHBT(ARG1,ARG2,ARG3) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \ + __ASM ("pkhbt %0, %1, %2, lsl %3" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2), "I" (ARG3) ); \ + __RES; \ + }) + +#define __PKHTB(ARG1,ARG2,ARG3) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \ + if (ARG3 == 0) \ + __ASM ("pkhtb %0, %1, %2" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2) ); \ + else \ + __ASM ("pkhtb %0, %1, %2, asr %3" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2), "I" (ARG3) ); \ + __RES; \ + }) +#endif + +#define __PKHBT(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) | \ + ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) ) + +#define __PKHTB(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0xFFFF0000UL) | \ + ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL) ) + +__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3) +{ + int32_t result; + + __ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r" (op1), "r" (op2), "r" (op3) ); + return(result); +} + +#endif /* (__ARM_FEATURE_DSP == 1) */ +/*@} end of group CMSIS_SIMD_intrinsics */ + + +#pragma GCC diagnostic pop + +#endif /* __CMSIS_GCC_H */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_iccarm.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_iccarm.h new file mode 100644 index 0000000000..12d68fd9a6 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_iccarm.h @@ -0,0 +1,964 @@ +/**************************************************************************//** + * @file cmsis_iccarm.h + * @brief CMSIS compiler ICCARM (IAR Compiler for Arm) header file + * @version V5.1.0 + * @date 08. May 2019 + ******************************************************************************/ + +//------------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019 IAR Systems +// Copyright (c) 2017-2019 Arm Limited. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License") +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------ + + +#ifndef __CMSIS_ICCARM_H__ +#define __CMSIS_ICCARM_H__ + +#ifndef __ICCARM__ + #error This file should only be compiled by ICCARM +#endif + +#pragma system_include + +#define __IAR_FT _Pragma("inline=forced") __intrinsic + +#if (__VER__ >= 8000000) + #define __ICCARM_V8 1 +#else + #define __ICCARM_V8 0 +#endif + +#ifndef __ALIGNED + #if __ICCARM_V8 + #define __ALIGNED(x) __attribute__((aligned(x))) + #elif (__VER__ >= 7080000) + /* Needs IAR language extensions */ + #define __ALIGNED(x) __attribute__((aligned(x))) + #else + #warning No compiler specific solution for __ALIGNED.__ALIGNED is ignored. + #define __ALIGNED(x) + #endif +#endif + + +/* Define compiler macros for CPU architecture, used in CMSIS 5. + */ +#if __ARM_ARCH_6M__ || __ARM_ARCH_7M__ || __ARM_ARCH_7EM__ || __ARM_ARCH_8M_BASE__ || __ARM_ARCH_8M_MAIN__ +/* Macros already defined */ +#else + #if defined(__ARM8M_MAINLINE__) || defined(__ARM8EM_MAINLINE__) + #define __ARM_ARCH_8M_MAIN__ 1 + #elif defined(__ARM8M_BASELINE__) + #define __ARM_ARCH_8M_BASE__ 1 + #elif defined(__ARM_ARCH_PROFILE) && __ARM_ARCH_PROFILE == 'M' + #if __ARM_ARCH == 6 + #define __ARM_ARCH_6M__ 1 + #elif __ARM_ARCH == 7 + #if __ARM_FEATURE_DSP + #define __ARM_ARCH_7EM__ 1 + #else + #define __ARM_ARCH_7M__ 1 + #endif + #endif /* __ARM_ARCH */ + #endif /* __ARM_ARCH_PROFILE == 'M' */ +#endif + +/* Alternativ core deduction for older ICCARM's */ +#if !defined(__ARM_ARCH_6M__) && !defined(__ARM_ARCH_7M__) && !defined(__ARM_ARCH_7EM__) && \ + !defined(__ARM_ARCH_8M_BASE__) && !defined(__ARM_ARCH_8M_MAIN__) + #if defined(__ARM6M__) && (__CORE__ == __ARM6M__) + #define __ARM_ARCH_6M__ 1 + #elif defined(__ARM7M__) && (__CORE__ == __ARM7M__) + #define __ARM_ARCH_7M__ 1 + #elif defined(__ARM7EM__) && (__CORE__ == __ARM7EM__) + #define __ARM_ARCH_7EM__ 1 + #elif defined(__ARM8M_BASELINE__) && (__CORE == __ARM8M_BASELINE__) + #define __ARM_ARCH_8M_BASE__ 1 + #elif defined(__ARM8M_MAINLINE__) && (__CORE == __ARM8M_MAINLINE__) + #define __ARM_ARCH_8M_MAIN__ 1 + #elif defined(__ARM8EM_MAINLINE__) && (__CORE == __ARM8EM_MAINLINE__) + #define __ARM_ARCH_8M_MAIN__ 1 + #else + #error "Unknown target." + #endif +#endif + + + +#if defined(__ARM_ARCH_6M__) && __ARM_ARCH_6M__==1 + #define __IAR_M0_FAMILY 1 +#elif defined(__ARM_ARCH_8M_BASE__) && __ARM_ARCH_8M_BASE__==1 + #define __IAR_M0_FAMILY 1 +#else + #define __IAR_M0_FAMILY 0 +#endif + + +#ifndef __ASM + #define __ASM __asm +#endif + +#ifndef __COMPILER_BARRIER + #define __COMPILER_BARRIER() __ASM volatile("":::"memory") +#endif + +#ifndef __INLINE + #define __INLINE inline +#endif + +#ifndef __NO_RETURN + #if __ICCARM_V8 + #define __NO_RETURN __attribute__((__noreturn__)) + #else + #define __NO_RETURN _Pragma("object_attribute=__noreturn") + #endif +#endif + +#ifndef __PACKED + #if __ICCARM_V8 + #define __PACKED __attribute__((packed, aligned(1))) + #else + /* Needs IAR language extensions */ + #define __PACKED __packed + #endif +#endif + +#ifndef __PACKED_STRUCT + #if __ICCARM_V8 + #define __PACKED_STRUCT struct __attribute__((packed, aligned(1))) + #else + /* Needs IAR language extensions */ + #define __PACKED_STRUCT __packed struct + #endif +#endif + +#ifndef __PACKED_UNION + #if __ICCARM_V8 + #define __PACKED_UNION union __attribute__((packed, aligned(1))) + #else + /* Needs IAR language extensions */ + #define __PACKED_UNION __packed union + #endif +#endif + +#ifndef __RESTRICT + #if __ICCARM_V8 + #define __RESTRICT __restrict + #else + /* Needs IAR language extensions */ + #define __RESTRICT restrict + #endif +#endif + +#ifndef __STATIC_INLINE + #define __STATIC_INLINE static inline +#endif + +#ifndef __FORCEINLINE + #define __FORCEINLINE _Pragma("inline=forced") +#endif + +#ifndef __STATIC_FORCEINLINE + #define __STATIC_FORCEINLINE __FORCEINLINE __STATIC_INLINE +#endif + +#ifndef __UNALIGNED_UINT16_READ +#pragma language=save +#pragma language=extended +__IAR_FT uint16_t __iar_uint16_read(void const *ptr) +{ + return *(__packed uint16_t*)(ptr); +} +#pragma language=restore +#define __UNALIGNED_UINT16_READ(PTR) __iar_uint16_read(PTR) +#endif + + +#ifndef __UNALIGNED_UINT16_WRITE +#pragma language=save +#pragma language=extended +__IAR_FT void __iar_uint16_write(void const *ptr, uint16_t val) +{ + *(__packed uint16_t*)(ptr) = val;; +} +#pragma language=restore +#define __UNALIGNED_UINT16_WRITE(PTR,VAL) __iar_uint16_write(PTR,VAL) +#endif + +#ifndef __UNALIGNED_UINT32_READ +#pragma language=save +#pragma language=extended +__IAR_FT uint32_t __iar_uint32_read(void const *ptr) +{ + return *(__packed uint32_t*)(ptr); +} +#pragma language=restore +#define __UNALIGNED_UINT32_READ(PTR) __iar_uint32_read(PTR) +#endif + +#ifndef __UNALIGNED_UINT32_WRITE +#pragma language=save +#pragma language=extended +__IAR_FT void __iar_uint32_write(void const *ptr, uint32_t val) +{ + *(__packed uint32_t*)(ptr) = val;; +} +#pragma language=restore +#define __UNALIGNED_UINT32_WRITE(PTR,VAL) __iar_uint32_write(PTR,VAL) +#endif + +#ifndef __UNALIGNED_UINT32 /* deprecated */ +#pragma language=save +#pragma language=extended +__packed struct __iar_u32 { uint32_t v; }; +#pragma language=restore +#define __UNALIGNED_UINT32(PTR) (((struct __iar_u32 *)(PTR))->v) +#endif + +#ifndef __USED + #if __ICCARM_V8 + #define __USED __attribute__((used)) + #else + #define __USED _Pragma("__root") + #endif +#endif + +#ifndef __WEAK + #if __ICCARM_V8 + #define __WEAK __attribute__((weak)) + #else + #define __WEAK _Pragma("__weak") + #endif +#endif + +#ifndef __PROGRAM_START +#define __PROGRAM_START __iar_program_start +#endif + +#ifndef __INITIAL_SP +#define __INITIAL_SP CSTACK$$Limit +#endif + +#ifndef __STACK_LIMIT +#define __STACK_LIMIT CSTACK$$Base +#endif + +#ifndef __VECTOR_TABLE +#define __VECTOR_TABLE __vector_table +#endif + +#ifndef __VECTOR_TABLE_ATTRIBUTE +#define __VECTOR_TABLE_ATTRIBUTE @".intvec" +#endif + +#ifndef __ICCARM_INTRINSICS_VERSION__ + #define __ICCARM_INTRINSICS_VERSION__ 0 +#endif + +#if __ICCARM_INTRINSICS_VERSION__ == 2 + + #if defined(__CLZ) + #undef __CLZ + #endif + #if defined(__REVSH) + #undef __REVSH + #endif + #if defined(__RBIT) + #undef __RBIT + #endif + #if defined(__SSAT) + #undef __SSAT + #endif + #if defined(__USAT) + #undef __USAT + #endif + + #include "iccarm_builtin.h" + + #define __disable_fault_irq __iar_builtin_disable_fiq + #define __disable_irq __iar_builtin_disable_interrupt + #define __enable_fault_irq __iar_builtin_enable_fiq + #define __enable_irq __iar_builtin_enable_interrupt + #define __arm_rsr __iar_builtin_rsr + #define __arm_wsr __iar_builtin_wsr + + + #define __get_APSR() (__arm_rsr("APSR")) + #define __get_BASEPRI() (__arm_rsr("BASEPRI")) + #define __get_CONTROL() (__arm_rsr("CONTROL")) + #define __get_FAULTMASK() (__arm_rsr("FAULTMASK")) + + #if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) ) + #define __get_FPSCR() (__arm_rsr("FPSCR")) + #define __set_FPSCR(VALUE) (__arm_wsr("FPSCR", (VALUE))) + #else + #define __get_FPSCR() ( 0 ) + #define __set_FPSCR(VALUE) ((void)VALUE) + #endif + + #define __get_IPSR() (__arm_rsr("IPSR")) + #define __get_MSP() (__arm_rsr("MSP")) + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + #define __get_MSPLIM() (0U) + #else + #define __get_MSPLIM() (__arm_rsr("MSPLIM")) + #endif + #define __get_PRIMASK() (__arm_rsr("PRIMASK")) + #define __get_PSP() (__arm_rsr("PSP")) + + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + #define __get_PSPLIM() (0U) + #else + #define __get_PSPLIM() (__arm_rsr("PSPLIM")) + #endif + + #define __get_xPSR() (__arm_rsr("xPSR")) + + #define __set_BASEPRI(VALUE) (__arm_wsr("BASEPRI", (VALUE))) + #define __set_BASEPRI_MAX(VALUE) (__arm_wsr("BASEPRI_MAX", (VALUE))) + #define __set_CONTROL(VALUE) (__arm_wsr("CONTROL", (VALUE))) + #define __set_FAULTMASK(VALUE) (__arm_wsr("FAULTMASK", (VALUE))) + #define __set_MSP(VALUE) (__arm_wsr("MSP", (VALUE))) + + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + #define __set_MSPLIM(VALUE) ((void)(VALUE)) + #else + #define __set_MSPLIM(VALUE) (__arm_wsr("MSPLIM", (VALUE))) + #endif + #define __set_PRIMASK(VALUE) (__arm_wsr("PRIMASK", (VALUE))) + #define __set_PSP(VALUE) (__arm_wsr("PSP", (VALUE))) + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + #define __set_PSPLIM(VALUE) ((void)(VALUE)) + #else + #define __set_PSPLIM(VALUE) (__arm_wsr("PSPLIM", (VALUE))) + #endif + + #define __TZ_get_CONTROL_NS() (__arm_rsr("CONTROL_NS")) + #define __TZ_set_CONTROL_NS(VALUE) (__arm_wsr("CONTROL_NS", (VALUE))) + #define __TZ_get_PSP_NS() (__arm_rsr("PSP_NS")) + #define __TZ_set_PSP_NS(VALUE) (__arm_wsr("PSP_NS", (VALUE))) + #define __TZ_get_MSP_NS() (__arm_rsr("MSP_NS")) + #define __TZ_set_MSP_NS(VALUE) (__arm_wsr("MSP_NS", (VALUE))) + #define __TZ_get_SP_NS() (__arm_rsr("SP_NS")) + #define __TZ_set_SP_NS(VALUE) (__arm_wsr("SP_NS", (VALUE))) + #define __TZ_get_PRIMASK_NS() (__arm_rsr("PRIMASK_NS")) + #define __TZ_set_PRIMASK_NS(VALUE) (__arm_wsr("PRIMASK_NS", (VALUE))) + #define __TZ_get_BASEPRI_NS() (__arm_rsr("BASEPRI_NS")) + #define __TZ_set_BASEPRI_NS(VALUE) (__arm_wsr("BASEPRI_NS", (VALUE))) + #define __TZ_get_FAULTMASK_NS() (__arm_rsr("FAULTMASK_NS")) + #define __TZ_set_FAULTMASK_NS(VALUE)(__arm_wsr("FAULTMASK_NS", (VALUE))) + + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + #define __TZ_get_PSPLIM_NS() (0U) + #define __TZ_set_PSPLIM_NS(VALUE) ((void)(VALUE)) + #else + #define __TZ_get_PSPLIM_NS() (__arm_rsr("PSPLIM_NS")) + #define __TZ_set_PSPLIM_NS(VALUE) (__arm_wsr("PSPLIM_NS", (VALUE))) + #endif + + #define __TZ_get_MSPLIM_NS() (__arm_rsr("MSPLIM_NS")) + #define __TZ_set_MSPLIM_NS(VALUE) (__arm_wsr("MSPLIM_NS", (VALUE))) + + #define __NOP __iar_builtin_no_operation + + #define __CLZ __iar_builtin_CLZ + #define __CLREX __iar_builtin_CLREX + + #define __DMB __iar_builtin_DMB + #define __DSB __iar_builtin_DSB + #define __ISB __iar_builtin_ISB + + #define __LDREXB __iar_builtin_LDREXB + #define __LDREXH __iar_builtin_LDREXH + #define __LDREXW __iar_builtin_LDREX + + #define __RBIT __iar_builtin_RBIT + #define __REV __iar_builtin_REV + #define __REV16 __iar_builtin_REV16 + + __IAR_FT int16_t __REVSH(int16_t val) + { + return (int16_t) __iar_builtin_REVSH(val); + } + + #define __ROR __iar_builtin_ROR + #define __RRX __iar_builtin_RRX + + #define __SEV __iar_builtin_SEV + + #if !__IAR_M0_FAMILY + #define __SSAT __iar_builtin_SSAT + #endif + + #define __STREXB __iar_builtin_STREXB + #define __STREXH __iar_builtin_STREXH + #define __STREXW __iar_builtin_STREX + + #if !__IAR_M0_FAMILY + #define __USAT __iar_builtin_USAT + #endif + + #define __WFE __iar_builtin_WFE + #define __WFI __iar_builtin_WFI + + #if __ARM_MEDIA__ + #define __SADD8 __iar_builtin_SADD8 + #define __QADD8 __iar_builtin_QADD8 + #define __SHADD8 __iar_builtin_SHADD8 + #define __UADD8 __iar_builtin_UADD8 + #define __UQADD8 __iar_builtin_UQADD8 + #define __UHADD8 __iar_builtin_UHADD8 + #define __SSUB8 __iar_builtin_SSUB8 + #define __QSUB8 __iar_builtin_QSUB8 + #define __SHSUB8 __iar_builtin_SHSUB8 + #define __USUB8 __iar_builtin_USUB8 + #define __UQSUB8 __iar_builtin_UQSUB8 + #define __UHSUB8 __iar_builtin_UHSUB8 + #define __SADD16 __iar_builtin_SADD16 + #define __QADD16 __iar_builtin_QADD16 + #define __SHADD16 __iar_builtin_SHADD16 + #define __UADD16 __iar_builtin_UADD16 + #define __UQADD16 __iar_builtin_UQADD16 + #define __UHADD16 __iar_builtin_UHADD16 + #define __SSUB16 __iar_builtin_SSUB16 + #define __QSUB16 __iar_builtin_QSUB16 + #define __SHSUB16 __iar_builtin_SHSUB16 + #define __USUB16 __iar_builtin_USUB16 + #define __UQSUB16 __iar_builtin_UQSUB16 + #define __UHSUB16 __iar_builtin_UHSUB16 + #define __SASX __iar_builtin_SASX + #define __QASX __iar_builtin_QASX + #define __SHASX __iar_builtin_SHASX + #define __UASX __iar_builtin_UASX + #define __UQASX __iar_builtin_UQASX + #define __UHASX __iar_builtin_UHASX + #define __SSAX __iar_builtin_SSAX + #define __QSAX __iar_builtin_QSAX + #define __SHSAX __iar_builtin_SHSAX + #define __USAX __iar_builtin_USAX + #define __UQSAX __iar_builtin_UQSAX + #define __UHSAX __iar_builtin_UHSAX + #define __USAD8 __iar_builtin_USAD8 + #define __USADA8 __iar_builtin_USADA8 + #define __SSAT16 __iar_builtin_SSAT16 + #define __USAT16 __iar_builtin_USAT16 + #define __UXTB16 __iar_builtin_UXTB16 + #define __UXTAB16 __iar_builtin_UXTAB16 + #define __SXTB16 __iar_builtin_SXTB16 + #define __SXTAB16 __iar_builtin_SXTAB16 + #define __SMUAD __iar_builtin_SMUAD + #define __SMUADX __iar_builtin_SMUADX + #define __SMMLA __iar_builtin_SMMLA + #define __SMLAD __iar_builtin_SMLAD + #define __SMLADX __iar_builtin_SMLADX + #define __SMLALD __iar_builtin_SMLALD + #define __SMLALDX __iar_builtin_SMLALDX + #define __SMUSD __iar_builtin_SMUSD + #define __SMUSDX __iar_builtin_SMUSDX + #define __SMLSD __iar_builtin_SMLSD + #define __SMLSDX __iar_builtin_SMLSDX + #define __SMLSLD __iar_builtin_SMLSLD + #define __SMLSLDX __iar_builtin_SMLSLDX + #define __SEL __iar_builtin_SEL + #define __QADD __iar_builtin_QADD + #define __QSUB __iar_builtin_QSUB + #define __PKHBT __iar_builtin_PKHBT + #define __PKHTB __iar_builtin_PKHTB + #endif + +#else /* __ICCARM_INTRINSICS_VERSION__ == 2 */ + + #if __IAR_M0_FAMILY + /* Avoid clash between intrinsics.h and arm_math.h when compiling for Cortex-M0. */ + #define __CLZ __cmsis_iar_clz_not_active + #define __SSAT __cmsis_iar_ssat_not_active + #define __USAT __cmsis_iar_usat_not_active + #define __RBIT __cmsis_iar_rbit_not_active + #define __get_APSR __cmsis_iar_get_APSR_not_active + #endif + + + #if (!((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) )) + #define __get_FPSCR __cmsis_iar_get_FPSR_not_active + #define __set_FPSCR __cmsis_iar_set_FPSR_not_active + #endif + + #ifdef __INTRINSICS_INCLUDED + #error intrinsics.h is already included previously! + #endif + + #include + + #if __IAR_M0_FAMILY + /* Avoid clash between intrinsics.h and arm_math.h when compiling for Cortex-M0. */ + #undef __CLZ + #undef __SSAT + #undef __USAT + #undef __RBIT + #undef __get_APSR + + __STATIC_INLINE uint8_t __CLZ(uint32_t data) + { + if (data == 0U) { return 32U; } + + uint32_t count = 0U; + uint32_t mask = 0x80000000U; + + while ((data & mask) == 0U) + { + count += 1U; + mask = mask >> 1U; + } + return count; + } + + __STATIC_INLINE uint32_t __RBIT(uint32_t v) + { + uint8_t sc = 31U; + uint32_t r = v; + for (v >>= 1U; v; v >>= 1U) + { + r <<= 1U; + r |= v & 1U; + sc--; + } + return (r << sc); + } + + __STATIC_INLINE uint32_t __get_APSR(void) + { + uint32_t res; + __asm("MRS %0,APSR" : "=r" (res)); + return res; + } + + #endif + + #if (!((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \ + (defined (__FPU_USED ) && (__FPU_USED == 1U)) )) + #undef __get_FPSCR + #undef __set_FPSCR + #define __get_FPSCR() (0) + #define __set_FPSCR(VALUE) ((void)VALUE) + #endif + + #pragma diag_suppress=Pe940 + #pragma diag_suppress=Pe177 + + #define __enable_irq __enable_interrupt + #define __disable_irq __disable_interrupt + #define __NOP __no_operation + + #define __get_xPSR __get_PSR + + #if (!defined(__ARM_ARCH_6M__) || __ARM_ARCH_6M__==0) + + __IAR_FT uint32_t __LDREXW(uint32_t volatile *ptr) + { + return __LDREX((unsigned long *)ptr); + } + + __IAR_FT uint32_t __STREXW(uint32_t value, uint32_t volatile *ptr) + { + return __STREX(value, (unsigned long *)ptr); + } + #endif + + + /* __CORTEX_M is defined in core_cm0.h, core_cm3.h and core_cm4.h. */ + #if (__CORTEX_M >= 0x03) + + __IAR_FT uint32_t __RRX(uint32_t value) + { + uint32_t result; + __ASM("RRX %0, %1" : "=r"(result) : "r" (value) : "cc"); + return(result); + } + + __IAR_FT void __set_BASEPRI_MAX(uint32_t value) + { + __asm volatile("MSR BASEPRI_MAX,%0"::"r" (value)); + } + + + #define __enable_fault_irq __enable_fiq + #define __disable_fault_irq __disable_fiq + + + #endif /* (__CORTEX_M >= 0x03) */ + + __IAR_FT uint32_t __ROR(uint32_t op1, uint32_t op2) + { + return (op1 >> op2) | (op1 << ((sizeof(op1)*8)-op2)); + } + + #if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) + + __IAR_FT uint32_t __get_MSPLIM(void) + { + uint32_t res; + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + res = 0U; + #else + __asm volatile("MRS %0,MSPLIM" : "=r" (res)); + #endif + return res; + } + + __IAR_FT void __set_MSPLIM(uint32_t value) + { + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure MSPLIM is RAZ/WI + (void)value; + #else + __asm volatile("MSR MSPLIM,%0" :: "r" (value)); + #endif + } + + __IAR_FT uint32_t __get_PSPLIM(void) + { + uint32_t res; + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + res = 0U; + #else + __asm volatile("MRS %0,PSPLIM" : "=r" (res)); + #endif + return res; + } + + __IAR_FT void __set_PSPLIM(uint32_t value) + { + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)value; + #else + __asm volatile("MSR PSPLIM,%0" :: "r" (value)); + #endif + } + + __IAR_FT uint32_t __TZ_get_CONTROL_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,CONTROL_NS" : "=r" (res)); + return res; + } + + __IAR_FT void __TZ_set_CONTROL_NS(uint32_t value) + { + __asm volatile("MSR CONTROL_NS,%0" :: "r" (value)); + } + + __IAR_FT uint32_t __TZ_get_PSP_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,PSP_NS" : "=r" (res)); + return res; + } + + __IAR_FT void __TZ_set_PSP_NS(uint32_t value) + { + __asm volatile("MSR PSP_NS,%0" :: "r" (value)); + } + + __IAR_FT uint32_t __TZ_get_MSP_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,MSP_NS" : "=r" (res)); + return res; + } + + __IAR_FT void __TZ_set_MSP_NS(uint32_t value) + { + __asm volatile("MSR MSP_NS,%0" :: "r" (value)); + } + + __IAR_FT uint32_t __TZ_get_SP_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,SP_NS" : "=r" (res)); + return res; + } + __IAR_FT void __TZ_set_SP_NS(uint32_t value) + { + __asm volatile("MSR SP_NS,%0" :: "r" (value)); + } + + __IAR_FT uint32_t __TZ_get_PRIMASK_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,PRIMASK_NS" : "=r" (res)); + return res; + } + + __IAR_FT void __TZ_set_PRIMASK_NS(uint32_t value) + { + __asm volatile("MSR PRIMASK_NS,%0" :: "r" (value)); + } + + __IAR_FT uint32_t __TZ_get_BASEPRI_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,BASEPRI_NS" : "=r" (res)); + return res; + } + + __IAR_FT void __TZ_set_BASEPRI_NS(uint32_t value) + { + __asm volatile("MSR BASEPRI_NS,%0" :: "r" (value)); + } + + __IAR_FT uint32_t __TZ_get_FAULTMASK_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,FAULTMASK_NS" : "=r" (res)); + return res; + } + + __IAR_FT void __TZ_set_FAULTMASK_NS(uint32_t value) + { + __asm volatile("MSR FAULTMASK_NS,%0" :: "r" (value)); + } + + __IAR_FT uint32_t __TZ_get_PSPLIM_NS(void) + { + uint32_t res; + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + res = 0U; + #else + __asm volatile("MRS %0,PSPLIM_NS" : "=r" (res)); + #endif + return res; + } + + __IAR_FT void __TZ_set_PSPLIM_NS(uint32_t value) + { + #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \ + (!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3))) + // without main extensions, the non-secure PSPLIM is RAZ/WI + (void)value; + #else + __asm volatile("MSR PSPLIM_NS,%0" :: "r" (value)); + #endif + } + + __IAR_FT uint32_t __TZ_get_MSPLIM_NS(void) + { + uint32_t res; + __asm volatile("MRS %0,MSPLIM_NS" : "=r" (res)); + return res; + } + + __IAR_FT void __TZ_set_MSPLIM_NS(uint32_t value) + { + __asm volatile("MSR MSPLIM_NS,%0" :: "r" (value)); + } + + #endif /* __ARM_ARCH_8M_MAIN__ or __ARM_ARCH_8M_BASE__ */ + +#endif /* __ICCARM_INTRINSICS_VERSION__ == 2 */ + +#define __BKPT(value) __asm volatile ("BKPT %0" : : "i"(value)) + +#if __IAR_M0_FAMILY + __STATIC_INLINE int32_t __SSAT(int32_t val, uint32_t sat) + { + if ((sat >= 1U) && (sat <= 32U)) + { + const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U); + const int32_t min = -1 - max ; + if (val > max) + { + return max; + } + else if (val < min) + { + return min; + } + } + return val; + } + + __STATIC_INLINE uint32_t __USAT(int32_t val, uint32_t sat) + { + if (sat <= 31U) + { + const uint32_t max = ((1U << sat) - 1U); + if (val > (int32_t)max) + { + return max; + } + else if (val < 0) + { + return 0U; + } + } + return (uint32_t)val; + } +#endif + +#if (__CORTEX_M >= 0x03) /* __CORTEX_M is defined in core_cm0.h, core_cm3.h and core_cm4.h. */ + + __IAR_FT uint8_t __LDRBT(volatile uint8_t *addr) + { + uint32_t res; + __ASM("LDRBT %0, [%1]" : "=r" (res) : "r" (addr) : "memory"); + return ((uint8_t)res); + } + + __IAR_FT uint16_t __LDRHT(volatile uint16_t *addr) + { + uint32_t res; + __ASM("LDRHT %0, [%1]" : "=r" (res) : "r" (addr) : "memory"); + return ((uint16_t)res); + } + + __IAR_FT uint32_t __LDRT(volatile uint32_t *addr) + { + uint32_t res; + __ASM("LDRT %0, [%1]" : "=r" (res) : "r" (addr) : "memory"); + return res; + } + + __IAR_FT void __STRBT(uint8_t value, volatile uint8_t *addr) + { + __ASM("STRBT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory"); + } + + __IAR_FT void __STRHT(uint16_t value, volatile uint16_t *addr) + { + __ASM("STRHT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory"); + } + + __IAR_FT void __STRT(uint32_t value, volatile uint32_t *addr) + { + __ASM("STRT %1, [%0]" : : "r" (addr), "r" (value) : "memory"); + } + +#endif /* (__CORTEX_M >= 0x03) */ + +#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \ + (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) + + + __IAR_FT uint8_t __LDAB(volatile uint8_t *ptr) + { + uint32_t res; + __ASM volatile ("LDAB %0, [%1]" : "=r" (res) : "r" (ptr) : "memory"); + return ((uint8_t)res); + } + + __IAR_FT uint16_t __LDAH(volatile uint16_t *ptr) + { + uint32_t res; + __ASM volatile ("LDAH %0, [%1]" : "=r" (res) : "r" (ptr) : "memory"); + return ((uint16_t)res); + } + + __IAR_FT uint32_t __LDA(volatile uint32_t *ptr) + { + uint32_t res; + __ASM volatile ("LDA %0, [%1]" : "=r" (res) : "r" (ptr) : "memory"); + return res; + } + + __IAR_FT void __STLB(uint8_t value, volatile uint8_t *ptr) + { + __ASM volatile ("STLB %1, [%0]" :: "r" (ptr), "r" (value) : "memory"); + } + + __IAR_FT void __STLH(uint16_t value, volatile uint16_t *ptr) + { + __ASM volatile ("STLH %1, [%0]" :: "r" (ptr), "r" (value) : "memory"); + } + + __IAR_FT void __STL(uint32_t value, volatile uint32_t *ptr) + { + __ASM volatile ("STL %1, [%0]" :: "r" (ptr), "r" (value) : "memory"); + } + + __IAR_FT uint8_t __LDAEXB(volatile uint8_t *ptr) + { + uint32_t res; + __ASM volatile ("LDAEXB %0, [%1]" : "=r" (res) : "r" (ptr) : "memory"); + return ((uint8_t)res); + } + + __IAR_FT uint16_t __LDAEXH(volatile uint16_t *ptr) + { + uint32_t res; + __ASM volatile ("LDAEXH %0, [%1]" : "=r" (res) : "r" (ptr) : "memory"); + return ((uint16_t)res); + } + + __IAR_FT uint32_t __LDAEX(volatile uint32_t *ptr) + { + uint32_t res; + __ASM volatile ("LDAEX %0, [%1]" : "=r" (res) : "r" (ptr) : "memory"); + return res; + } + + __IAR_FT uint32_t __STLEXB(uint8_t value, volatile uint8_t *ptr) + { + uint32_t res; + __ASM volatile ("STLEXB %0, %2, [%1]" : "=r" (res) : "r" (ptr), "r" (value) : "memory"); + return res; + } + + __IAR_FT uint32_t __STLEXH(uint16_t value, volatile uint16_t *ptr) + { + uint32_t res; + __ASM volatile ("STLEXH %0, %2, [%1]" : "=r" (res) : "r" (ptr), "r" (value) : "memory"); + return res; + } + + __IAR_FT uint32_t __STLEX(uint32_t value, volatile uint32_t *ptr) + { + uint32_t res; + __ASM volatile ("STLEX %0, %2, [%1]" : "=r" (res) : "r" (ptr), "r" (value) : "memory"); + return res; + } + +#endif /* __ARM_ARCH_8M_MAIN__ or __ARM_ARCH_8M_BASE__ */ + +#undef __IAR_FT +#undef __IAR_M0_FAMILY +#undef __ICCARM_V8 + +#pragma diag_default=Pe940 +#pragma diag_default=Pe177 + +#endif /* __CMSIS_ICCARM_H__ */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_version.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_version.h new file mode 100644 index 0000000000..f2e2746626 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/cmsis_version.h @@ -0,0 +1,39 @@ +/**************************************************************************//** + * @file cmsis_version.h + * @brief CMSIS Core(M) Version definitions + * @version V5.0.3 + * @date 24. June 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 ARM Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CMSIS_VERSION_H +#define __CMSIS_VERSION_H + +/* CMSIS Version definitions */ +#define __CM_CMSIS_VERSION_MAIN ( 5U) /*!< [31:16] CMSIS Core(M) main version */ +#define __CM_CMSIS_VERSION_SUB ( 3U) /*!< [15:0] CMSIS Core(M) sub version */ +#define __CM_CMSIS_VERSION ((__CM_CMSIS_VERSION_MAIN << 16U) | \ + __CM_CMSIS_VERSION_SUB ) /*!< CMSIS Core(M) version number */ +#endif diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv81mml.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv81mml.h new file mode 100644 index 0000000000..8441e57fb1 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv81mml.h @@ -0,0 +1,2968 @@ +/**************************************************************************//** + * @file core_armv81mml.h + * @brief CMSIS Armv8.1-M Mainline Core Peripheral Access Layer Header File + * @version V1.0.0 + * @date 15. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2018-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_ARMV81MML_H_GENERIC +#define __CORE_ARMV81MML_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_ARMV81MML + @{ + */ + +#include "cmsis_version.h" + +#define __ARM_ARCH_8M_MAIN__ 1 // patching for now +/* CMSIS ARMV81MML definitions */ +#define __ARMv81MML_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __ARMv81MML_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __ARMv81MML_CMSIS_VERSION ((__ARMv81MML_CMSIS_VERSION_MAIN << 16U) | \ + __ARMv81MML_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (81U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions. +*/ +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_ARMV81MML_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_ARMV81MML_H_DEPENDANT +#define __CORE_ARMV81MML_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __ARMv81MML_REV + #define __ARMv81MML_REV 0x0000U + #warning "__ARMv81MML_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __SAUREGION_PRESENT + #define __SAUREGION_PRESENT 0U + #warning "__SAUREGION_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __DSP_PRESENT + #define __DSP_PRESENT 0U + #warning "__DSP_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group ARMv81MML */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core SAU Register + - Core FPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + +#define APSR_GE_Pos 16U /*!< APSR: GE Position */ +#define APSR_GE_Msk (0xFUL << APSR_GE_Pos) /*!< APSR: GE Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:7; /*!< bit: 9..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t IT:2; /*!< bit: 25..26 saved IT state (read 0) */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_IT_Pos 25U /*!< xPSR: IT Position */ +#define xPSR_IT_Msk (3UL << xPSR_IT_Pos) /*!< xPSR: IT Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_GE_Pos 16U /*!< xPSR: GE Position */ +#define xPSR_GE_Msk (0xFUL << xPSR_GE_Pos) /*!< xPSR: GE Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack-pointer select */ + uint32_t FPCA:1; /*!< bit: 2 Floating-point context active */ + uint32_t SFPA:1; /*!< bit: 3 Secure floating-point active */ + uint32_t _reserved1:28; /*!< bit: 4..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SFPA_Pos 3U /*!< CONTROL: SFPA Position */ +#define CONTROL_SFPA_Msk (1UL << CONTROL_SFPA_Pos) /*!< CONTROL: SFPA Mask */ + +#define CONTROL_FPCA_Pos 2U /*!< CONTROL: FPCA Position */ +#define CONTROL_FPCA_Msk (1UL << CONTROL_FPCA_Pos) /*!< CONTROL: FPCA Mask */ + +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[16U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[16U]; + __IOM uint32_t ICER[16U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[16U]; + __IOM uint32_t ISPR[16U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[16U]; + __IOM uint32_t ICPR[16U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[16U]; + __IOM uint32_t IABR[16U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[16U]; + __IOM uint32_t ITNS[16U]; /*!< Offset: 0x280 (R/W) Interrupt Non-Secure State Register */ + uint32_t RESERVED5[16U]; + __IOM uint8_t IPR[496U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED6[580U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHPR[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t ID_PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t ID_DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ID_ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t ID_MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ID_ISAR[6U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + __IM uint32_t CLIDR; /*!< Offset: 0x078 (R/ ) Cache Level ID register */ + __IM uint32_t CTR; /*!< Offset: 0x07C (R/ ) Cache Type register */ + __IM uint32_t CCSIDR; /*!< Offset: 0x080 (R/ ) Cache Size ID Register */ + __IOM uint32_t CSSELR; /*!< Offset: 0x084 (R/W) Cache Size Selection Register */ + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ + __IOM uint32_t NSACR; /*!< Offset: 0x08C (R/W) Non-Secure Access Control Register */ + uint32_t RESERVED3[92U]; + __OM uint32_t STIR; /*!< Offset: 0x200 ( /W) Software Triggered Interrupt Register */ + uint32_t RESERVED4[15U]; + __IM uint32_t MVFR0; /*!< Offset: 0x240 (R/ ) Media and VFP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x244 (R/ ) Media and VFP Feature Register 1 */ + __IM uint32_t MVFR2; /*!< Offset: 0x248 (R/ ) Media and VFP Feature Register 2 */ + uint32_t RESERVED5[1U]; + __OM uint32_t ICIALLU; /*!< Offset: 0x250 ( /W) I-Cache Invalidate All to PoU */ + uint32_t RESERVED6[1U]; + __OM uint32_t ICIMVAU; /*!< Offset: 0x258 ( /W) I-Cache Invalidate by MVA to PoU */ + __OM uint32_t DCIMVAC; /*!< Offset: 0x25C ( /W) D-Cache Invalidate by MVA to PoC */ + __OM uint32_t DCISW; /*!< Offset: 0x260 ( /W) D-Cache Invalidate by Set-way */ + __OM uint32_t DCCMVAU; /*!< Offset: 0x264 ( /W) D-Cache Clean by MVA to PoU */ + __OM uint32_t DCCMVAC; /*!< Offset: 0x268 ( /W) D-Cache Clean by MVA to PoC */ + __OM uint32_t DCCSW; /*!< Offset: 0x26C ( /W) D-Cache Clean by Set-way */ + __OM uint32_t DCCIMVAC; /*!< Offset: 0x270 ( /W) D-Cache Clean and Invalidate by MVA to PoC */ + __OM uint32_t DCCISW; /*!< Offset: 0x274 ( /W) D-Cache Clean and Invalidate by Set-way */ + uint32_t RESERVED7[6U]; + __IOM uint32_t ITCMCR; /*!< Offset: 0x290 (R/W) Instruction Tightly-Coupled Memory Control Register */ + __IOM uint32_t DTCMCR; /*!< Offset: 0x294 (R/W) Data Tightly-Coupled Memory Control Registers */ + __IOM uint32_t AHBPCR; /*!< Offset: 0x298 (R/W) AHBP Control Register */ + __IOM uint32_t CACR; /*!< Offset: 0x29C (R/W) L1 Cache Control Register */ + __IOM uint32_t AHBSCR; /*!< Offset: 0x2A0 (R/W) AHB Slave Control Register */ + uint32_t RESERVED8[1U]; + __IOM uint32_t ABFSR; /*!< Offset: 0x2A8 (R/W) Auxiliary Bus Fault Status Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_PENDNMISET_Pos 31U /*!< SCB ICSR: PENDNMISET Position */ +#define SCB_ICSR_PENDNMISET_Msk (1UL << SCB_ICSR_PENDNMISET_Pos) /*!< SCB ICSR: PENDNMISET Mask */ + +#define SCB_ICSR_NMIPENDSET_Pos SCB_ICSR_PENDNMISET_Pos /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */ +#define SCB_ICSR_NMIPENDSET_Msk SCB_ICSR_PENDNMISET_Msk /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */ + +#define SCB_ICSR_PENDNMICLR_Pos 30U /*!< SCB ICSR: PENDNMICLR Position */ +#define SCB_ICSR_PENDNMICLR_Msk (1UL << SCB_ICSR_PENDNMICLR_Pos) /*!< SCB ICSR: PENDNMICLR Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_STTNS_Pos 24U /*!< SCB ICSR: STTNS Position (Security Extension) */ +#define SCB_ICSR_STTNS_Msk (1UL << SCB_ICSR_STTNS_Pos) /*!< SCB ICSR: STTNS Mask (Security Extension) */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIS_Pos 14U /*!< SCB AIRCR: PRIS Position */ +#define SCB_AIRCR_PRIS_Msk (1UL << SCB_AIRCR_PRIS_Pos) /*!< SCB AIRCR: PRIS Mask */ + +#define SCB_AIRCR_BFHFNMINS_Pos 13U /*!< SCB AIRCR: BFHFNMINS Position */ +#define SCB_AIRCR_BFHFNMINS_Msk (1UL << SCB_AIRCR_BFHFNMINS_Pos) /*!< SCB AIRCR: BFHFNMINS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQS_Pos 3U /*!< SCB AIRCR: SYSRESETREQS Position */ +#define SCB_AIRCR_SYSRESETREQS_Msk (1UL << SCB_AIRCR_SYSRESETREQS_Pos) /*!< SCB AIRCR: SYSRESETREQS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEPS_Pos 3U /*!< SCB SCR: SLEEPDEEPS Position */ +#define SCB_SCR_SLEEPDEEPS_Msk (1UL << SCB_SCR_SLEEPDEEPS_Pos) /*!< SCB SCR: SLEEPDEEPS Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_BP_Pos 18U /*!< SCB CCR: BP Position */ +#define SCB_CCR_BP_Msk (1UL << SCB_CCR_BP_Pos) /*!< SCB CCR: BP Mask */ + +#define SCB_CCR_IC_Pos 17U /*!< SCB CCR: IC Position */ +#define SCB_CCR_IC_Msk (1UL << SCB_CCR_IC_Pos) /*!< SCB CCR: IC Mask */ + +#define SCB_CCR_DC_Pos 16U /*!< SCB CCR: DC Position */ +#define SCB_CCR_DC_Msk (1UL << SCB_CCR_DC_Pos) /*!< SCB CCR: DC Mask */ + +#define SCB_CCR_STKOFHFNMIGN_Pos 10U /*!< SCB CCR: STKOFHFNMIGN Position */ +#define SCB_CCR_STKOFHFNMIGN_Msk (1UL << SCB_CCR_STKOFHFNMIGN_Pos) /*!< SCB CCR: STKOFHFNMIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_HARDFAULTPENDED_Pos 21U /*!< SCB SHCSR: HARDFAULTPENDED Position */ +#define SCB_SHCSR_HARDFAULTPENDED_Msk (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos) /*!< SCB SHCSR: HARDFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTPENDED_Pos 20U /*!< SCB SHCSR: SECUREFAULTPENDED Position */ +#define SCB_SHCSR_SECUREFAULTPENDED_Msk (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos) /*!< SCB SHCSR: SECUREFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTENA_Pos 19U /*!< SCB SHCSR: SECUREFAULTENA Position */ +#define SCB_SHCSR_SECUREFAULTENA_Msk (1UL << SCB_SHCSR_SECUREFAULTENA_Pos) /*!< SCB SHCSR: SECUREFAULTENA Mask */ + +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_NMIACT_Pos 5U /*!< SCB SHCSR: NMIACT Position */ +#define SCB_SHCSR_NMIACT_Msk (1UL << SCB_SHCSR_NMIACT_Pos) /*!< SCB SHCSR: NMIACT Mask */ + +#define SCB_SHCSR_SECUREFAULTACT_Pos 4U /*!< SCB SHCSR: SECUREFAULTACT Position */ +#define SCB_SHCSR_SECUREFAULTACT_Msk (1UL << SCB_SHCSR_SECUREFAULTACT_Pos) /*!< SCB SHCSR: SECUREFAULTACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_HARDFAULTACT_Pos 2U /*!< SCB SHCSR: HARDFAULTACT Position */ +#define SCB_SHCSR_HARDFAULTACT_Msk (1UL << SCB_SHCSR_HARDFAULTACT_Pos) /*!< SCB SHCSR: HARDFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MLSPERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 5U) /*!< SCB CFSR (MMFSR): MLSPERR Position */ +#define SCB_CFSR_MLSPERR_Msk (1UL << SCB_CFSR_MLSPERR_Pos) /*!< SCB CFSR (MMFSR): MLSPERR Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_LSPERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 5U) /*!< SCB CFSR (BFSR): LSPERR Position */ +#define SCB_CFSR_LSPERR_Msk (1UL << SCB_CFSR_LSPERR_Pos) /*!< SCB CFSR (BFSR): LSPERR Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_STKOF_Pos (SCB_CFSR_USGFAULTSR_Pos + 4U) /*!< SCB CFSR (UFSR): STKOF Position */ +#define SCB_CFSR_STKOF_Msk (1UL << SCB_CFSR_STKOF_Pos) /*!< SCB CFSR (UFSR): STKOF Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/* SCB Non-Secure Access Control Register Definitions */ +#define SCB_NSACR_CP11_Pos 11U /*!< SCB NSACR: CP11 Position */ +#define SCB_NSACR_CP11_Msk (1UL << SCB_NSACR_CP11_Pos) /*!< SCB NSACR: CP11 Mask */ + +#define SCB_NSACR_CP10_Pos 10U /*!< SCB NSACR: CP10 Position */ +#define SCB_NSACR_CP10_Msk (1UL << SCB_NSACR_CP10_Pos) /*!< SCB NSACR: CP10 Mask */ + +#define SCB_NSACR_CPn_Pos 0U /*!< SCB NSACR: CPn Position */ +#define SCB_NSACR_CPn_Msk (1UL /*<< SCB_NSACR_CPn_Pos*/) /*!< SCB NSACR: CPn Mask */ + +/* SCB Cache Level ID Register Definitions */ +#define SCB_CLIDR_LOUU_Pos 27U /*!< SCB CLIDR: LoUU Position */ +#define SCB_CLIDR_LOUU_Msk (7UL << SCB_CLIDR_LOUU_Pos) /*!< SCB CLIDR: LoUU Mask */ + +#define SCB_CLIDR_LOC_Pos 24U /*!< SCB CLIDR: LoC Position */ +#define SCB_CLIDR_LOC_Msk (7UL << SCB_CLIDR_LOC_Pos) /*!< SCB CLIDR: LoC Mask */ + +/* SCB Cache Type Register Definitions */ +#define SCB_CTR_FORMAT_Pos 29U /*!< SCB CTR: Format Position */ +#define SCB_CTR_FORMAT_Msk (7UL << SCB_CTR_FORMAT_Pos) /*!< SCB CTR: Format Mask */ + +#define SCB_CTR_CWG_Pos 24U /*!< SCB CTR: CWG Position */ +#define SCB_CTR_CWG_Msk (0xFUL << SCB_CTR_CWG_Pos) /*!< SCB CTR: CWG Mask */ + +#define SCB_CTR_ERG_Pos 20U /*!< SCB CTR: ERG Position */ +#define SCB_CTR_ERG_Msk (0xFUL << SCB_CTR_ERG_Pos) /*!< SCB CTR: ERG Mask */ + +#define SCB_CTR_DMINLINE_Pos 16U /*!< SCB CTR: DminLine Position */ +#define SCB_CTR_DMINLINE_Msk (0xFUL << SCB_CTR_DMINLINE_Pos) /*!< SCB CTR: DminLine Mask */ + +#define SCB_CTR_IMINLINE_Pos 0U /*!< SCB CTR: ImInLine Position */ +#define SCB_CTR_IMINLINE_Msk (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/) /*!< SCB CTR: ImInLine Mask */ + +/* SCB Cache Size ID Register Definitions */ +#define SCB_CCSIDR_WT_Pos 31U /*!< SCB CCSIDR: WT Position */ +#define SCB_CCSIDR_WT_Msk (1UL << SCB_CCSIDR_WT_Pos) /*!< SCB CCSIDR: WT Mask */ + +#define SCB_CCSIDR_WB_Pos 30U /*!< SCB CCSIDR: WB Position */ +#define SCB_CCSIDR_WB_Msk (1UL << SCB_CCSIDR_WB_Pos) /*!< SCB CCSIDR: WB Mask */ + +#define SCB_CCSIDR_RA_Pos 29U /*!< SCB CCSIDR: RA Position */ +#define SCB_CCSIDR_RA_Msk (1UL << SCB_CCSIDR_RA_Pos) /*!< SCB CCSIDR: RA Mask */ + +#define SCB_CCSIDR_WA_Pos 28U /*!< SCB CCSIDR: WA Position */ +#define SCB_CCSIDR_WA_Msk (1UL << SCB_CCSIDR_WA_Pos) /*!< SCB CCSIDR: WA Mask */ + +#define SCB_CCSIDR_NUMSETS_Pos 13U /*!< SCB CCSIDR: NumSets Position */ +#define SCB_CCSIDR_NUMSETS_Msk (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos) /*!< SCB CCSIDR: NumSets Mask */ + +#define SCB_CCSIDR_ASSOCIATIVITY_Pos 3U /*!< SCB CCSIDR: Associativity Position */ +#define SCB_CCSIDR_ASSOCIATIVITY_Msk (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos) /*!< SCB CCSIDR: Associativity Mask */ + +#define SCB_CCSIDR_LINESIZE_Pos 0U /*!< SCB CCSIDR: LineSize Position */ +#define SCB_CCSIDR_LINESIZE_Msk (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/) /*!< SCB CCSIDR: LineSize Mask */ + +/* SCB Cache Size Selection Register Definitions */ +#define SCB_CSSELR_LEVEL_Pos 1U /*!< SCB CSSELR: Level Position */ +#define SCB_CSSELR_LEVEL_Msk (7UL << SCB_CSSELR_LEVEL_Pos) /*!< SCB CSSELR: Level Mask */ + +#define SCB_CSSELR_IND_Pos 0U /*!< SCB CSSELR: InD Position */ +#define SCB_CSSELR_IND_Msk (1UL /*<< SCB_CSSELR_IND_Pos*/) /*!< SCB CSSELR: InD Mask */ + +/* SCB Software Triggered Interrupt Register Definitions */ +#define SCB_STIR_INTID_Pos 0U /*!< SCB STIR: INTID Position */ +#define SCB_STIR_INTID_Msk (0x1FFUL /*<< SCB_STIR_INTID_Pos*/) /*!< SCB STIR: INTID Mask */ + +/* SCB D-Cache Invalidate by Set-way Register Definitions */ +#define SCB_DCISW_WAY_Pos 30U /*!< SCB DCISW: Way Position */ +#define SCB_DCISW_WAY_Msk (3UL << SCB_DCISW_WAY_Pos) /*!< SCB DCISW: Way Mask */ + +#define SCB_DCISW_SET_Pos 5U /*!< SCB DCISW: Set Position */ +#define SCB_DCISW_SET_Msk (0x1FFUL << SCB_DCISW_SET_Pos) /*!< SCB DCISW: Set Mask */ + +/* SCB D-Cache Clean by Set-way Register Definitions */ +#define SCB_DCCSW_WAY_Pos 30U /*!< SCB DCCSW: Way Position */ +#define SCB_DCCSW_WAY_Msk (3UL << SCB_DCCSW_WAY_Pos) /*!< SCB DCCSW: Way Mask */ + +#define SCB_DCCSW_SET_Pos 5U /*!< SCB DCCSW: Set Position */ +#define SCB_DCCSW_SET_Msk (0x1FFUL << SCB_DCCSW_SET_Pos) /*!< SCB DCCSW: Set Mask */ + +/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */ +#define SCB_DCCISW_WAY_Pos 30U /*!< SCB DCCISW: Way Position */ +#define SCB_DCCISW_WAY_Msk (3UL << SCB_DCCISW_WAY_Pos) /*!< SCB DCCISW: Way Mask */ + +#define SCB_DCCISW_SET_Pos 5U /*!< SCB DCCISW: Set Position */ +#define SCB_DCCISW_SET_Msk (0x1FFUL << SCB_DCCISW_SET_Pos) /*!< SCB DCCISW: Set Mask */ + +/* Instruction Tightly-Coupled Memory Control Register Definitions */ +#define SCB_ITCMCR_SZ_Pos 3U /*!< SCB ITCMCR: SZ Position */ +#define SCB_ITCMCR_SZ_Msk (0xFUL << SCB_ITCMCR_SZ_Pos) /*!< SCB ITCMCR: SZ Mask */ + +#define SCB_ITCMCR_RETEN_Pos 2U /*!< SCB ITCMCR: RETEN Position */ +#define SCB_ITCMCR_RETEN_Msk (1UL << SCB_ITCMCR_RETEN_Pos) /*!< SCB ITCMCR: RETEN Mask */ + +#define SCB_ITCMCR_RMW_Pos 1U /*!< SCB ITCMCR: RMW Position */ +#define SCB_ITCMCR_RMW_Msk (1UL << SCB_ITCMCR_RMW_Pos) /*!< SCB ITCMCR: RMW Mask */ + +#define SCB_ITCMCR_EN_Pos 0U /*!< SCB ITCMCR: EN Position */ +#define SCB_ITCMCR_EN_Msk (1UL /*<< SCB_ITCMCR_EN_Pos*/) /*!< SCB ITCMCR: EN Mask */ + +/* Data Tightly-Coupled Memory Control Register Definitions */ +#define SCB_DTCMCR_SZ_Pos 3U /*!< SCB DTCMCR: SZ Position */ +#define SCB_DTCMCR_SZ_Msk (0xFUL << SCB_DTCMCR_SZ_Pos) /*!< SCB DTCMCR: SZ Mask */ + +#define SCB_DTCMCR_RETEN_Pos 2U /*!< SCB DTCMCR: RETEN Position */ +#define SCB_DTCMCR_RETEN_Msk (1UL << SCB_DTCMCR_RETEN_Pos) /*!< SCB DTCMCR: RETEN Mask */ + +#define SCB_DTCMCR_RMW_Pos 1U /*!< SCB DTCMCR: RMW Position */ +#define SCB_DTCMCR_RMW_Msk (1UL << SCB_DTCMCR_RMW_Pos) /*!< SCB DTCMCR: RMW Mask */ + +#define SCB_DTCMCR_EN_Pos 0U /*!< SCB DTCMCR: EN Position */ +#define SCB_DTCMCR_EN_Msk (1UL /*<< SCB_DTCMCR_EN_Pos*/) /*!< SCB DTCMCR: EN Mask */ + +/* AHBP Control Register Definitions */ +#define SCB_AHBPCR_SZ_Pos 1U /*!< SCB AHBPCR: SZ Position */ +#define SCB_AHBPCR_SZ_Msk (7UL << SCB_AHBPCR_SZ_Pos) /*!< SCB AHBPCR: SZ Mask */ + +#define SCB_AHBPCR_EN_Pos 0U /*!< SCB AHBPCR: EN Position */ +#define SCB_AHBPCR_EN_Msk (1UL /*<< SCB_AHBPCR_EN_Pos*/) /*!< SCB AHBPCR: EN Mask */ + +/* L1 Cache Control Register Definitions */ +#define SCB_CACR_FORCEWT_Pos 2U /*!< SCB CACR: FORCEWT Position */ +#define SCB_CACR_FORCEWT_Msk (1UL << SCB_CACR_FORCEWT_Pos) /*!< SCB CACR: FORCEWT Mask */ + +#define SCB_CACR_ECCEN_Pos 1U /*!< SCB CACR: ECCEN Position */ +#define SCB_CACR_ECCEN_Msk (1UL << SCB_CACR_ECCEN_Pos) /*!< SCB CACR: ECCEN Mask */ + +#define SCB_CACR_SIWT_Pos 0U /*!< SCB CACR: SIWT Position */ +#define SCB_CACR_SIWT_Msk (1UL /*<< SCB_CACR_SIWT_Pos*/) /*!< SCB CACR: SIWT Mask */ + +/* AHBS Control Register Definitions */ +#define SCB_AHBSCR_INITCOUNT_Pos 11U /*!< SCB AHBSCR: INITCOUNT Position */ +#define SCB_AHBSCR_INITCOUNT_Msk (0x1FUL << SCB_AHBPCR_INITCOUNT_Pos) /*!< SCB AHBSCR: INITCOUNT Mask */ + +#define SCB_AHBSCR_TPRI_Pos 2U /*!< SCB AHBSCR: TPRI Position */ +#define SCB_AHBSCR_TPRI_Msk (0x1FFUL << SCB_AHBPCR_TPRI_Pos) /*!< SCB AHBSCR: TPRI Mask */ + +#define SCB_AHBSCR_CTL_Pos 0U /*!< SCB AHBSCR: CTL Position*/ +#define SCB_AHBSCR_CTL_Msk (3UL /*<< SCB_AHBPCR_CTL_Pos*/) /*!< SCB AHBSCR: CTL Mask */ + +/* Auxiliary Bus Fault Status Register Definitions */ +#define SCB_ABFSR_AXIMTYPE_Pos 8U /*!< SCB ABFSR: AXIMTYPE Position*/ +#define SCB_ABFSR_AXIMTYPE_Msk (3UL << SCB_ABFSR_AXIMTYPE_Pos) /*!< SCB ABFSR: AXIMTYPE Mask */ + +#define SCB_ABFSR_EPPB_Pos 4U /*!< SCB ABFSR: EPPB Position*/ +#define SCB_ABFSR_EPPB_Msk (1UL << SCB_ABFSR_EPPB_Pos) /*!< SCB ABFSR: EPPB Mask */ + +#define SCB_ABFSR_AXIM_Pos 3U /*!< SCB ABFSR: AXIM Position*/ +#define SCB_ABFSR_AXIM_Msk (1UL << SCB_ABFSR_AXIM_Pos) /*!< SCB ABFSR: AXIM Mask */ + +#define SCB_ABFSR_AHBP_Pos 2U /*!< SCB ABFSR: AHBP Position*/ +#define SCB_ABFSR_AHBP_Msk (1UL << SCB_ABFSR_AHBP_Pos) /*!< SCB ABFSR: AHBP Mask */ + +#define SCB_ABFSR_DTCM_Pos 1U /*!< SCB ABFSR: DTCM Position*/ +#define SCB_ABFSR_DTCM_Msk (1UL << SCB_ABFSR_DTCM_Pos) /*!< SCB ABFSR: DTCM Mask */ + +#define SCB_ABFSR_ITCM_Pos 0U /*!< SCB ABFSR: ITCM Position*/ +#define SCB_ABFSR_ITCM_Msk (1UL /*<< SCB_ABFSR_ITCM_Pos*/) /*!< SCB ABFSR: ITCM Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ + __IOM uint32_t CPPWR; /*!< Offset: 0x00C (R/W) Coprocessor Power Control Register */ +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[29U]; + __OM uint32_t IWR; /*!< Offset: 0xEF8 ( /W) ITM Integration Write Register */ + __IM uint32_t IRR; /*!< Offset: 0xEFC (R/ ) ITM Integration Read Register */ + __IOM uint32_t IMCR; /*!< Offset: 0xF00 (R/W) ITM Integration Mode Control Register */ + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) ITM Device Architecture Register */ + uint32_t RESERVED6[4U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Stimulus Port Register Definitions */ +#define ITM_STIM_DISABLED_Pos 1U /*!< ITM STIM: DISABLED Position */ +#define ITM_STIM_DISABLED_Msk (0x1UL << ITM_STIM_DISABLED_Pos) /*!< ITM STIM: DISABLED Mask */ + +#define ITM_STIM_FIFOREADY_Pos 0U /*!< ITM STIM: FIFOREADY Position */ +#define ITM_STIM_FIFOREADY_Msk (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/) /*!< ITM STIM: FIFOREADY Mask */ + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TRACEBUSID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TRACEBUSID_Msk (0x7FUL << ITM_TCR_TRACEBUSID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPRESCALE_Pos 8U /*!< ITM TCR: TSPRESCALE Position */ +#define ITM_TCR_TSPRESCALE_Msk (3UL << ITM_TCR_TSPRESCALE_Pos) /*!< ITM TCR: TSPRESCALE Mask */ + +#define ITM_TCR_STALLENA_Pos 5U /*!< ITM TCR: STALLENA Position */ +#define ITM_TCR_STALLENA_Msk (1UL << ITM_TCR_STALLENA_Pos) /*!< ITM TCR: STALLENA Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Integration Write Register Definitions */ +#define ITM_IWR_ATVALIDM_Pos 0U /*!< ITM IWR: ATVALIDM Position */ +#define ITM_IWR_ATVALIDM_Msk (1UL /*<< ITM_IWR_ATVALIDM_Pos*/) /*!< ITM IWR: ATVALIDM Mask */ + +/* ITM Integration Read Register Definitions */ +#define ITM_IRR_ATREADYM_Pos 0U /*!< ITM IRR: ATREADYM Position */ +#define ITM_IRR_ATREADYM_Msk (1UL /*<< ITM_IRR_ATREADYM_Pos*/) /*!< ITM IRR: ATREADYM Mask */ + +/* ITM Integration Mode Control Register Definitions */ +#define ITM_IMCR_INTEGRATION_Pos 0U /*!< ITM IMCR: INTEGRATION Position */ +#define ITM_IMCR_INTEGRATION_Msk (1UL /*<< ITM_IMCR_INTEGRATION_Pos*/) /*!< ITM IMCR: INTEGRATION Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + uint32_t RESERVED3[1U]; + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED4[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + uint32_t RESERVED5[1U]; + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED6[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + uint32_t RESERVED7[1U]; + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ + uint32_t RESERVED8[1U]; + __IOM uint32_t COMP4; /*!< Offset: 0x060 (R/W) Comparator Register 4 */ + uint32_t RESERVED9[1U]; + __IOM uint32_t FUNCTION4; /*!< Offset: 0x068 (R/W) Function Register 4 */ + uint32_t RESERVED10[1U]; + __IOM uint32_t COMP5; /*!< Offset: 0x070 (R/W) Comparator Register 5 */ + uint32_t RESERVED11[1U]; + __IOM uint32_t FUNCTION5; /*!< Offset: 0x078 (R/W) Function Register 5 */ + uint32_t RESERVED12[1U]; + __IOM uint32_t COMP6; /*!< Offset: 0x080 (R/W) Comparator Register 6 */ + uint32_t RESERVED13[1U]; + __IOM uint32_t FUNCTION6; /*!< Offset: 0x088 (R/W) Function Register 6 */ + uint32_t RESERVED14[1U]; + __IOM uint32_t COMP7; /*!< Offset: 0x090 (R/W) Comparator Register 7 */ + uint32_t RESERVED15[1U]; + __IOM uint32_t FUNCTION7; /*!< Offset: 0x098 (R/W) Function Register 7 */ + uint32_t RESERVED16[1U]; + __IOM uint32_t COMP8; /*!< Offset: 0x0A0 (R/W) Comparator Register 8 */ + uint32_t RESERVED17[1U]; + __IOM uint32_t FUNCTION8; /*!< Offset: 0x0A8 (R/W) Function Register 8 */ + uint32_t RESERVED18[1U]; + __IOM uint32_t COMP9; /*!< Offset: 0x0B0 (R/W) Comparator Register 9 */ + uint32_t RESERVED19[1U]; + __IOM uint32_t FUNCTION9; /*!< Offset: 0x0B8 (R/W) Function Register 9 */ + uint32_t RESERVED20[1U]; + __IOM uint32_t COMP10; /*!< Offset: 0x0C0 (R/W) Comparator Register 10 */ + uint32_t RESERVED21[1U]; + __IOM uint32_t FUNCTION10; /*!< Offset: 0x0C8 (R/W) Function Register 10 */ + uint32_t RESERVED22[1U]; + __IOM uint32_t COMP11; /*!< Offset: 0x0D0 (R/W) Comparator Register 11 */ + uint32_t RESERVED23[1U]; + __IOM uint32_t FUNCTION11; /*!< Offset: 0x0D8 (R/W) Function Register 11 */ + uint32_t RESERVED24[1U]; + __IOM uint32_t COMP12; /*!< Offset: 0x0E0 (R/W) Comparator Register 12 */ + uint32_t RESERVED25[1U]; + __IOM uint32_t FUNCTION12; /*!< Offset: 0x0E8 (R/W) Function Register 12 */ + uint32_t RESERVED26[1U]; + __IOM uint32_t COMP13; /*!< Offset: 0x0F0 (R/W) Comparator Register 13 */ + uint32_t RESERVED27[1U]; + __IOM uint32_t FUNCTION13; /*!< Offset: 0x0F8 (R/W) Function Register 13 */ + uint32_t RESERVED28[1U]; + __IOM uint32_t COMP14; /*!< Offset: 0x100 (R/W) Comparator Register 14 */ + uint32_t RESERVED29[1U]; + __IOM uint32_t FUNCTION14; /*!< Offset: 0x108 (R/W) Function Register 14 */ + uint32_t RESERVED30[1U]; + __IOM uint32_t COMP15; /*!< Offset: 0x110 (R/W) Comparator Register 15 */ + uint32_t RESERVED31[1U]; + __IOM uint32_t FUNCTION15; /*!< Offset: 0x118 (R/W) Function Register 15 */ + uint32_t RESERVED32[934U]; + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R ) Lock Status Register */ + uint32_t RESERVED33[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) Device Architecture Register */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCDISS_Pos 23U /*!< DWT CTRL: CYCDISS Position */ +#define DWT_CTRL_CYCDISS_Msk (0x1UL << DWT_CTRL_CYCDISS_Pos) /*!< DWT CTRL: CYCDISS Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_ID_Pos 27U /*!< DWT FUNCTION: ID Position */ +#define DWT_FUNCTION_ID_Msk (0x1FUL << DWT_FUNCTION_ID_Pos) /*!< DWT FUNCTION: ID Mask */ + +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_ACTION_Pos 4U /*!< DWT FUNCTION: ACTION Position */ +#define DWT_FUNCTION_ACTION_Msk (0x1UL << DWT_FUNCTION_ACTION_Pos) /*!< DWT FUNCTION: ACTION Mask */ + +#define DWT_FUNCTION_MATCH_Pos 0U /*!< DWT FUNCTION: MATCH Position */ +#define DWT_FUNCTION_MATCH_Msk (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/) /*!< DWT FUNCTION: MATCH Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Sizes Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Sizes Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IM uint32_t FSCR; /*!< Offset: 0x308 (R/ ) Formatter Synchronization Counter Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER */ + __IM uint32_t FIFO0; /*!< Offset: 0xEEC (R/ ) Integration ETM Data */ + __IM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/ ) ITATBCTR2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) ITATBCTR0 */ + __IM uint32_t FIFO1; /*!< Offset: 0xEFC (R/ ) Integration ITM Data */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) TPIU_DEVID */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) TPIU_DEVTYPE */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration ETM Data Register Definitions (FIFO0) */ +#define TPI_FIFO0_ITM_ATVALID_Pos 29U /*!< TPI FIFO0: ITM_ATVALID Position */ +#define TPI_FIFO0_ITM_ATVALID_Msk (0x3UL << TPI_FIFO0_ITM_ATVALID_Pos) /*!< TPI FIFO0: ITM_ATVALID Mask */ + +#define TPI_FIFO0_ITM_bytecount_Pos 27U /*!< TPI FIFO0: ITM_bytecount Position */ +#define TPI_FIFO0_ITM_bytecount_Msk (0x3UL << TPI_FIFO0_ITM_bytecount_Pos) /*!< TPI FIFO0: ITM_bytecount Mask */ + +#define TPI_FIFO0_ETM_ATVALID_Pos 26U /*!< TPI FIFO0: ETM_ATVALID Position */ +#define TPI_FIFO0_ETM_ATVALID_Msk (0x3UL << TPI_FIFO0_ETM_ATVALID_Pos) /*!< TPI FIFO0: ETM_ATVALID Mask */ + +#define TPI_FIFO0_ETM_bytecount_Pos 24U /*!< TPI FIFO0: ETM_bytecount Position */ +#define TPI_FIFO0_ETM_bytecount_Msk (0x3UL << TPI_FIFO0_ETM_bytecount_Pos) /*!< TPI FIFO0: ETM_bytecount Mask */ + +#define TPI_FIFO0_ETM2_Pos 16U /*!< TPI FIFO0: ETM2 Position */ +#define TPI_FIFO0_ETM2_Msk (0xFFUL << TPI_FIFO0_ETM2_Pos) /*!< TPI FIFO0: ETM2 Mask */ + +#define TPI_FIFO0_ETM1_Pos 8U /*!< TPI FIFO0: ETM1 Position */ +#define TPI_FIFO0_ETM1_Msk (0xFFUL << TPI_FIFO0_ETM1_Pos) /*!< TPI FIFO0: ETM1 Mask */ + +#define TPI_FIFO0_ETM0_Pos 0U /*!< TPI FIFO0: ETM0 Position */ +#define TPI_FIFO0_ETM0_Msk (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/) /*!< TPI FIFO0: ETM0 Mask */ + +/* TPI ITATBCTR2 Register Definitions */ +#define TPI_ITATBCTR2_ATREADY_Pos 0U /*!< TPI ITATBCTR2: ATREADY Position */ +#define TPI_ITATBCTR2_ATREADY_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY_Pos*/) /*!< TPI ITATBCTR2: ATREADY Mask */ + +/* TPI Integration ITM Data Register Definitions (FIFO1) */ +#define TPI_FIFO1_ITM_ATVALID_Pos 29U /*!< TPI FIFO1: ITM_ATVALID Position */ +#define TPI_FIFO1_ITM_ATVALID_Msk (0x3UL << TPI_FIFO1_ITM_ATVALID_Pos) /*!< TPI FIFO1: ITM_ATVALID Mask */ + +#define TPI_FIFO1_ITM_bytecount_Pos 27U /*!< TPI FIFO1: ITM_bytecount Position */ +#define TPI_FIFO1_ITM_bytecount_Msk (0x3UL << TPI_FIFO1_ITM_bytecount_Pos) /*!< TPI FIFO1: ITM_bytecount Mask */ + +#define TPI_FIFO1_ETM_ATVALID_Pos 26U /*!< TPI FIFO1: ETM_ATVALID Position */ +#define TPI_FIFO1_ETM_ATVALID_Msk (0x3UL << TPI_FIFO1_ETM_ATVALID_Pos) /*!< TPI FIFO1: ETM_ATVALID Mask */ + +#define TPI_FIFO1_ETM_bytecount_Pos 24U /*!< TPI FIFO1: ETM_bytecount Position */ +#define TPI_FIFO1_ETM_bytecount_Msk (0x3UL << TPI_FIFO1_ETM_bytecount_Pos) /*!< TPI FIFO1: ETM_bytecount Mask */ + +#define TPI_FIFO1_ITM2_Pos 16U /*!< TPI FIFO1: ITM2 Position */ +#define TPI_FIFO1_ITM2_Msk (0xFFUL << TPI_FIFO1_ITM2_Pos) /*!< TPI FIFO1: ITM2 Mask */ + +#define TPI_FIFO1_ITM1_Pos 8U /*!< TPI FIFO1: ITM1 Position */ +#define TPI_FIFO1_ITM1_Msk (0xFFUL << TPI_FIFO1_ITM1_Pos) /*!< TPI FIFO1: ITM1 Mask */ + +#define TPI_FIFO1_ITM0_Pos 0U /*!< TPI FIFO1: ITM0 Position */ +#define TPI_FIFO1_ITM0_Msk (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/) /*!< TPI FIFO1: ITM0 Mask */ + +/* TPI ITATBCTR0 Register Definitions */ +#define TPI_ITATBCTR0_ATREADY_Pos 0U /*!< TPI ITATBCTR0: ATREADY Position */ +#define TPI_ITATBCTR0_ATREADY_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY_Pos*/) /*!< TPI ITATBCTR0: ATREADY Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x1UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_MinBufSz_Pos 6U /*!< TPI DEVID: MinBufSz Position */ +#define TPI_DEVID_MinBufSz_Msk (0x7UL << TPI_DEVID_MinBufSz_Pos) /*!< TPI DEVID: MinBufSz Mask */ + +#define TPI_DEVID_AsynClkIn_Pos 5U /*!< TPI DEVID: AsynClkIn Position */ +#define TPI_DEVID_AsynClkIn_Msk (0x1UL << TPI_DEVID_AsynClkIn_Pos) /*!< TPI DEVID: AsynClkIn Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_MajorType_Pos 4U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +#define TPI_DEVTYPE_SubType_Pos 0U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) MPU Region Limit Address Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Region Base Address Register Alias 1 */ + __IOM uint32_t RLAR_A1; /*!< Offset: 0x018 (R/W) MPU Region Limit Address Register Alias 1 */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Region Base Address Register Alias 2 */ + __IOM uint32_t RLAR_A2; /*!< Offset: 0x020 (R/W) MPU Region Limit Address Register Alias 2 */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Region Base Address Register Alias 3 */ + __IOM uint32_t RLAR_A3; /*!< Offset: 0x028 (R/W) MPU Region Limit Address Register Alias 3 */ + uint32_t RESERVED0[1]; + union { + __IOM uint32_t MAIR[2]; + struct { + __IOM uint32_t MAIR0; /*!< Offset: 0x030 (R/W) MPU Memory Attribute Indirection Register 0 */ + __IOM uint32_t MAIR1; /*!< Offset: 0x034 (R/W) MPU Memory Attribute Indirection Register 1 */ + }; + }; +} MPU_Type; + +#define MPU_TYPE_RALIASES 4U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_ADDR_Pos 5U /*!< MPU RBAR: ADDR Position */ +#define MPU_RBAR_ADDR_Msk (0x7FFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */ + +#define MPU_RBAR_SH_Pos 3U /*!< MPU RBAR: SH Position */ +#define MPU_RBAR_SH_Msk (0x3UL << MPU_RBAR_SH_Pos) /*!< MPU RBAR: SH Mask */ + +#define MPU_RBAR_AP_Pos 1U /*!< MPU RBAR: AP Position */ +#define MPU_RBAR_AP_Msk (0x3UL << MPU_RBAR_AP_Pos) /*!< MPU RBAR: AP Mask */ + +#define MPU_RBAR_XN_Pos 0U /*!< MPU RBAR: XN Position */ +#define MPU_RBAR_XN_Msk (01UL /*<< MPU_RBAR_XN_Pos*/) /*!< MPU RBAR: XN Mask */ + +/* MPU Region Limit Address Register Definitions */ +#define MPU_RLAR_LIMIT_Pos 5U /*!< MPU RLAR: LIMIT Position */ +#define MPU_RLAR_LIMIT_Msk (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos) /*!< MPU RLAR: LIMIT Mask */ + +#define MPU_RLAR_PXN_Pos 4U /*!< MPU RLAR: PXN Position */ +#define MPU_RLAR_PXN_Msk (0x1UL << MPU_RLAR_PXN_Pos) /*!< MPU RLAR: PXN Mask */ + +#define MPU_RLAR_AttrIndx_Pos 1U /*!< MPU RLAR: AttrIndx Position */ +#define MPU_RLAR_AttrIndx_Msk (0x7UL << MPU_RLAR_AttrIndx_Pos) /*!< MPU RLAR: AttrIndx Mask */ + +#define MPU_RLAR_EN_Pos 0U /*!< MPU RLAR: Region enable bit Position */ +#define MPU_RLAR_EN_Msk (1UL /*<< MPU_RLAR_EN_Pos*/) /*!< MPU RLAR: Region enable bit Disable Mask */ + +/* MPU Memory Attribute Indirection Register 0 Definitions */ +#define MPU_MAIR0_Attr3_Pos 24U /*!< MPU MAIR0: Attr3 Position */ +#define MPU_MAIR0_Attr3_Msk (0xFFUL << MPU_MAIR0_Attr3_Pos) /*!< MPU MAIR0: Attr3 Mask */ + +#define MPU_MAIR0_Attr2_Pos 16U /*!< MPU MAIR0: Attr2 Position */ +#define MPU_MAIR0_Attr2_Msk (0xFFUL << MPU_MAIR0_Attr2_Pos) /*!< MPU MAIR0: Attr2 Mask */ + +#define MPU_MAIR0_Attr1_Pos 8U /*!< MPU MAIR0: Attr1 Position */ +#define MPU_MAIR0_Attr1_Msk (0xFFUL << MPU_MAIR0_Attr1_Pos) /*!< MPU MAIR0: Attr1 Mask */ + +#define MPU_MAIR0_Attr0_Pos 0U /*!< MPU MAIR0: Attr0 Position */ +#define MPU_MAIR0_Attr0_Msk (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/) /*!< MPU MAIR0: Attr0 Mask */ + +/* MPU Memory Attribute Indirection Register 1 Definitions */ +#define MPU_MAIR1_Attr7_Pos 24U /*!< MPU MAIR1: Attr7 Position */ +#define MPU_MAIR1_Attr7_Msk (0xFFUL << MPU_MAIR1_Attr7_Pos) /*!< MPU MAIR1: Attr7 Mask */ + +#define MPU_MAIR1_Attr6_Pos 16U /*!< MPU MAIR1: Attr6 Position */ +#define MPU_MAIR1_Attr6_Msk (0xFFUL << MPU_MAIR1_Attr6_Pos) /*!< MPU MAIR1: Attr6 Mask */ + +#define MPU_MAIR1_Attr5_Pos 8U /*!< MPU MAIR1: Attr5 Position */ +#define MPU_MAIR1_Attr5_Msk (0xFFUL << MPU_MAIR1_Attr5_Pos) /*!< MPU MAIR1: Attr5 Mask */ + +#define MPU_MAIR1_Attr4_Pos 0U /*!< MPU MAIR1: Attr4 Position */ +#define MPU_MAIR1_Attr4_Msk (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/) /*!< MPU MAIR1: Attr4 Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SAU Security Attribution Unit (SAU) + \brief Type definitions for the Security Attribution Unit (SAU) + @{ + */ + +/** + \brief Structure type to access the Security Attribution Unit (SAU). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SAU Control Register */ + __IM uint32_t TYPE; /*!< Offset: 0x004 (R/ ) SAU Type Register */ +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) SAU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) SAU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) SAU Region Limit Address Register */ +#else + uint32_t RESERVED0[3]; +#endif + __IOM uint32_t SFSR; /*!< Offset: 0x014 (R/W) Secure Fault Status Register */ + __IOM uint32_t SFAR; /*!< Offset: 0x018 (R/W) Secure Fault Address Register */ +} SAU_Type; + +/* SAU Control Register Definitions */ +#define SAU_CTRL_ALLNS_Pos 1U /*!< SAU CTRL: ALLNS Position */ +#define SAU_CTRL_ALLNS_Msk (1UL << SAU_CTRL_ALLNS_Pos) /*!< SAU CTRL: ALLNS Mask */ + +#define SAU_CTRL_ENABLE_Pos 0U /*!< SAU CTRL: ENABLE Position */ +#define SAU_CTRL_ENABLE_Msk (1UL /*<< SAU_CTRL_ENABLE_Pos*/) /*!< SAU CTRL: ENABLE Mask */ + +/* SAU Type Register Definitions */ +#define SAU_TYPE_SREGION_Pos 0U /*!< SAU TYPE: SREGION Position */ +#define SAU_TYPE_SREGION_Msk (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/) /*!< SAU TYPE: SREGION Mask */ + +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) +/* SAU Region Number Register Definitions */ +#define SAU_RNR_REGION_Pos 0U /*!< SAU RNR: REGION Position */ +#define SAU_RNR_REGION_Msk (0xFFUL /*<< SAU_RNR_REGION_Pos*/) /*!< SAU RNR: REGION Mask */ + +/* SAU Region Base Address Register Definitions */ +#define SAU_RBAR_BADDR_Pos 5U /*!< SAU RBAR: BADDR Position */ +#define SAU_RBAR_BADDR_Msk (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos) /*!< SAU RBAR: BADDR Mask */ + +/* SAU Region Limit Address Register Definitions */ +#define SAU_RLAR_LADDR_Pos 5U /*!< SAU RLAR: LADDR Position */ +#define SAU_RLAR_LADDR_Msk (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos) /*!< SAU RLAR: LADDR Mask */ + +#define SAU_RLAR_NSC_Pos 1U /*!< SAU RLAR: NSC Position */ +#define SAU_RLAR_NSC_Msk (1UL << SAU_RLAR_NSC_Pos) /*!< SAU RLAR: NSC Mask */ + +#define SAU_RLAR_ENABLE_Pos 0U /*!< SAU RLAR: ENABLE Position */ +#define SAU_RLAR_ENABLE_Msk (1UL /*<< SAU_RLAR_ENABLE_Pos*/) /*!< SAU RLAR: ENABLE Mask */ + +#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */ + +/* Secure Fault Status Register Definitions */ +#define SAU_SFSR_LSERR_Pos 7U /*!< SAU SFSR: LSERR Position */ +#define SAU_SFSR_LSERR_Msk (1UL << SAU_SFSR_LSERR_Pos) /*!< SAU SFSR: LSERR Mask */ + +#define SAU_SFSR_SFARVALID_Pos 6U /*!< SAU SFSR: SFARVALID Position */ +#define SAU_SFSR_SFARVALID_Msk (1UL << SAU_SFSR_SFARVALID_Pos) /*!< SAU SFSR: SFARVALID Mask */ + +#define SAU_SFSR_LSPERR_Pos 5U /*!< SAU SFSR: LSPERR Position */ +#define SAU_SFSR_LSPERR_Msk (1UL << SAU_SFSR_LSPERR_Pos) /*!< SAU SFSR: LSPERR Mask */ + +#define SAU_SFSR_INVTRAN_Pos 4U /*!< SAU SFSR: INVTRAN Position */ +#define SAU_SFSR_INVTRAN_Msk (1UL << SAU_SFSR_INVTRAN_Pos) /*!< SAU SFSR: INVTRAN Mask */ + +#define SAU_SFSR_AUVIOL_Pos 3U /*!< SAU SFSR: AUVIOL Position */ +#define SAU_SFSR_AUVIOL_Msk (1UL << SAU_SFSR_AUVIOL_Pos) /*!< SAU SFSR: AUVIOL Mask */ + +#define SAU_SFSR_INVER_Pos 2U /*!< SAU SFSR: INVER Position */ +#define SAU_SFSR_INVER_Msk (1UL << SAU_SFSR_INVER_Pos) /*!< SAU SFSR: INVER Mask */ + +#define SAU_SFSR_INVIS_Pos 1U /*!< SAU SFSR: INVIS Position */ +#define SAU_SFSR_INVIS_Msk (1UL << SAU_SFSR_INVIS_Pos) /*!< SAU SFSR: INVIS Mask */ + +#define SAU_SFSR_INVEP_Pos 0U /*!< SAU SFSR: INVEP Position */ +#define SAU_SFSR_INVEP_Msk (1UL /*<< SAU_SFSR_INVEP_Pos*/) /*!< SAU SFSR: INVEP Mask */ + +/*@} end of group CMSIS_SAU */ +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_FPU Floating Point Unit (FPU) + \brief Type definitions for the Floating Point Unit (FPU) + @{ + */ + +/** + \brief Structure type to access the Floating Point Unit (FPU). + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IOM uint32_t FPCCR; /*!< Offset: 0x004 (R/W) Floating-Point Context Control Register */ + __IOM uint32_t FPCAR; /*!< Offset: 0x008 (R/W) Floating-Point Context Address Register */ + __IOM uint32_t FPDSCR; /*!< Offset: 0x00C (R/W) Floating-Point Default Status Control Register */ + __IM uint32_t MVFR0; /*!< Offset: 0x010 (R/ ) Media and FP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x014 (R/ ) Media and FP Feature Register 1 */ +} FPU_Type; + +/* Floating-Point Context Control Register Definitions */ +#define FPU_FPCCR_ASPEN_Pos 31U /*!< FPCCR: ASPEN bit Position */ +#define FPU_FPCCR_ASPEN_Msk (1UL << FPU_FPCCR_ASPEN_Pos) /*!< FPCCR: ASPEN bit Mask */ + +#define FPU_FPCCR_LSPEN_Pos 30U /*!< FPCCR: LSPEN Position */ +#define FPU_FPCCR_LSPEN_Msk (1UL << FPU_FPCCR_LSPEN_Pos) /*!< FPCCR: LSPEN bit Mask */ + +#define FPU_FPCCR_LSPENS_Pos 29U /*!< FPCCR: LSPENS Position */ +#define FPU_FPCCR_LSPENS_Msk (1UL << FPU_FPCCR_LSPENS_Pos) /*!< FPCCR: LSPENS bit Mask */ + +#define FPU_FPCCR_CLRONRET_Pos 28U /*!< FPCCR: CLRONRET Position */ +#define FPU_FPCCR_CLRONRET_Msk (1UL << FPU_FPCCR_CLRONRET_Pos) /*!< FPCCR: CLRONRET bit Mask */ + +#define FPU_FPCCR_CLRONRETS_Pos 27U /*!< FPCCR: CLRONRETS Position */ +#define FPU_FPCCR_CLRONRETS_Msk (1UL << FPU_FPCCR_CLRONRETS_Pos) /*!< FPCCR: CLRONRETS bit Mask */ + +#define FPU_FPCCR_TS_Pos 26U /*!< FPCCR: TS Position */ +#define FPU_FPCCR_TS_Msk (1UL << FPU_FPCCR_TS_Pos) /*!< FPCCR: TS bit Mask */ + +#define FPU_FPCCR_UFRDY_Pos 10U /*!< FPCCR: UFRDY Position */ +#define FPU_FPCCR_UFRDY_Msk (1UL << FPU_FPCCR_UFRDY_Pos) /*!< FPCCR: UFRDY bit Mask */ + +#define FPU_FPCCR_SPLIMVIOL_Pos 9U /*!< FPCCR: SPLIMVIOL Position */ +#define FPU_FPCCR_SPLIMVIOL_Msk (1UL << FPU_FPCCR_SPLIMVIOL_Pos) /*!< FPCCR: SPLIMVIOL bit Mask */ + +#define FPU_FPCCR_MONRDY_Pos 8U /*!< FPCCR: MONRDY Position */ +#define FPU_FPCCR_MONRDY_Msk (1UL << FPU_FPCCR_MONRDY_Pos) /*!< FPCCR: MONRDY bit Mask */ + +#define FPU_FPCCR_SFRDY_Pos 7U /*!< FPCCR: SFRDY Position */ +#define FPU_FPCCR_SFRDY_Msk (1UL << FPU_FPCCR_SFRDY_Pos) /*!< FPCCR: SFRDY bit Mask */ + +#define FPU_FPCCR_BFRDY_Pos 6U /*!< FPCCR: BFRDY Position */ +#define FPU_FPCCR_BFRDY_Msk (1UL << FPU_FPCCR_BFRDY_Pos) /*!< FPCCR: BFRDY bit Mask */ + +#define FPU_FPCCR_MMRDY_Pos 5U /*!< FPCCR: MMRDY Position */ +#define FPU_FPCCR_MMRDY_Msk (1UL << FPU_FPCCR_MMRDY_Pos) /*!< FPCCR: MMRDY bit Mask */ + +#define FPU_FPCCR_HFRDY_Pos 4U /*!< FPCCR: HFRDY Position */ +#define FPU_FPCCR_HFRDY_Msk (1UL << FPU_FPCCR_HFRDY_Pos) /*!< FPCCR: HFRDY bit Mask */ + +#define FPU_FPCCR_THREAD_Pos 3U /*!< FPCCR: processor mode bit Position */ +#define FPU_FPCCR_THREAD_Msk (1UL << FPU_FPCCR_THREAD_Pos) /*!< FPCCR: processor mode active bit Mask */ + +#define FPU_FPCCR_S_Pos 2U /*!< FPCCR: Security status of the FP context bit Position */ +#define FPU_FPCCR_S_Msk (1UL << FPU_FPCCR_S_Pos) /*!< FPCCR: Security status of the FP context bit Mask */ + +#define FPU_FPCCR_USER_Pos 1U /*!< FPCCR: privilege level bit Position */ +#define FPU_FPCCR_USER_Msk (1UL << FPU_FPCCR_USER_Pos) /*!< FPCCR: privilege level bit Mask */ + +#define FPU_FPCCR_LSPACT_Pos 0U /*!< FPCCR: Lazy state preservation active bit Position */ +#define FPU_FPCCR_LSPACT_Msk (1UL /*<< FPU_FPCCR_LSPACT_Pos*/) /*!< FPCCR: Lazy state preservation active bit Mask */ + +/* Floating-Point Context Address Register Definitions */ +#define FPU_FPCAR_ADDRESS_Pos 3U /*!< FPCAR: ADDRESS bit Position */ +#define FPU_FPCAR_ADDRESS_Msk (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos) /*!< FPCAR: ADDRESS bit Mask */ + +/* Floating-Point Default Status Control Register Definitions */ +#define FPU_FPDSCR_AHP_Pos 26U /*!< FPDSCR: AHP bit Position */ +#define FPU_FPDSCR_AHP_Msk (1UL << FPU_FPDSCR_AHP_Pos) /*!< FPDSCR: AHP bit Mask */ + +#define FPU_FPDSCR_DN_Pos 25U /*!< FPDSCR: DN bit Position */ +#define FPU_FPDSCR_DN_Msk (1UL << FPU_FPDSCR_DN_Pos) /*!< FPDSCR: DN bit Mask */ + +#define FPU_FPDSCR_FZ_Pos 24U /*!< FPDSCR: FZ bit Position */ +#define FPU_FPDSCR_FZ_Msk (1UL << FPU_FPDSCR_FZ_Pos) /*!< FPDSCR: FZ bit Mask */ + +#define FPU_FPDSCR_RMode_Pos 22U /*!< FPDSCR: RMode bit Position */ +#define FPU_FPDSCR_RMode_Msk (3UL << FPU_FPDSCR_RMode_Pos) /*!< FPDSCR: RMode bit Mask */ + +/* Media and FP Feature Register 0 Definitions */ +#define FPU_MVFR0_FP_rounding_modes_Pos 28U /*!< MVFR0: FP rounding modes bits Position */ +#define FPU_MVFR0_FP_rounding_modes_Msk (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos) /*!< MVFR0: FP rounding modes bits Mask */ + +#define FPU_MVFR0_Short_vectors_Pos 24U /*!< MVFR0: Short vectors bits Position */ +#define FPU_MVFR0_Short_vectors_Msk (0xFUL << FPU_MVFR0_Short_vectors_Pos) /*!< MVFR0: Short vectors bits Mask */ + +#define FPU_MVFR0_Square_root_Pos 20U /*!< MVFR0: Square root bits Position */ +#define FPU_MVFR0_Square_root_Msk (0xFUL << FPU_MVFR0_Square_root_Pos) /*!< MVFR0: Square root bits Mask */ + +#define FPU_MVFR0_Divide_Pos 16U /*!< MVFR0: Divide bits Position */ +#define FPU_MVFR0_Divide_Msk (0xFUL << FPU_MVFR0_Divide_Pos) /*!< MVFR0: Divide bits Mask */ + +#define FPU_MVFR0_FP_excep_trapping_Pos 12U /*!< MVFR0: FP exception trapping bits Position */ +#define FPU_MVFR0_FP_excep_trapping_Msk (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos) /*!< MVFR0: FP exception trapping bits Mask */ + +#define FPU_MVFR0_Double_precision_Pos 8U /*!< MVFR0: Double-precision bits Position */ +#define FPU_MVFR0_Double_precision_Msk (0xFUL << FPU_MVFR0_Double_precision_Pos) /*!< MVFR0: Double-precision bits Mask */ + +#define FPU_MVFR0_Single_precision_Pos 4U /*!< MVFR0: Single-precision bits Position */ +#define FPU_MVFR0_Single_precision_Msk (0xFUL << FPU_MVFR0_Single_precision_Pos) /*!< MVFR0: Single-precision bits Mask */ + +#define FPU_MVFR0_A_SIMD_registers_Pos 0U /*!< MVFR0: A_SIMD registers bits Position */ +#define FPU_MVFR0_A_SIMD_registers_Msk (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/) /*!< MVFR0: A_SIMD registers bits Mask */ + +/* Media and FP Feature Register 1 Definitions */ +#define FPU_MVFR1_FP_fused_MAC_Pos 28U /*!< MVFR1: FP fused MAC bits Position */ +#define FPU_MVFR1_FP_fused_MAC_Msk (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos) /*!< MVFR1: FP fused MAC bits Mask */ + +#define FPU_MVFR1_FP_HPFP_Pos 24U /*!< MVFR1: FP HPFP bits Position */ +#define FPU_MVFR1_FP_HPFP_Msk (0xFUL << FPU_MVFR1_FP_HPFP_Pos) /*!< MVFR1: FP HPFP bits Mask */ + +#define FPU_MVFR1_D_NaN_mode_Pos 4U /*!< MVFR1: D_NaN mode bits Position */ +#define FPU_MVFR1_D_NaN_mode_Msk (0xFUL << FPU_MVFR1_D_NaN_mode_Pos) /*!< MVFR1: D_NaN mode bits Mask */ + +#define FPU_MVFR1_FtZ_mode_Pos 0U /*!< MVFR1: FtZ mode bits Position */ +#define FPU_MVFR1_FtZ_mode_Msk (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/) /*!< MVFR1: FtZ mode bits Mask */ + +/*@} end of group CMSIS_FPU */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ + uint32_t RESERVED4[1U]; + __IOM uint32_t DAUTHCTRL; /*!< Offset: 0x014 (R/W) Debug Authentication Control Register */ + __IOM uint32_t DSCSR; /*!< Offset: 0x018 (R/W) Debug Security Control and Status Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESTART_ST_Pos 26U /*!< CoreDebug DHCSR: S_RESTART_ST Position */ +#define CoreDebug_DHCSR_S_RESTART_ST_Msk (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos) /*!< CoreDebug DHCSR: S_RESTART_ST Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/* Debug Authentication Control Register Definitions */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos 3U /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */ + +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos 2U /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos) /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */ + +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos 1U /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */ +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */ + +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos 0U /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */ + +/* Debug Security Control and Status Register Definitions */ +#define CoreDebug_DSCSR_CDS_Pos 16U /*!< CoreDebug DSCSR: CDS Position */ +#define CoreDebug_DSCSR_CDS_Msk (1UL << CoreDebug_DSCSR_CDS_Pos) /*!< CoreDebug DSCSR: CDS Mask */ + +#define CoreDebug_DSCSR_SBRSEL_Pos 1U /*!< CoreDebug DSCSR: SBRSEL Position */ +#define CoreDebug_DSCSR_SBRSEL_Msk (1UL << CoreDebug_DSCSR_SBRSEL_Pos) /*!< CoreDebug DSCSR: SBRSEL Mask */ + +#define CoreDebug_DSCSR_SBRSELEN_Pos 0U /*!< CoreDebug DSCSR: SBRSELEN Position */ +#define CoreDebug_DSCSR_SBRSELEN_Msk (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/) /*!< CoreDebug DSCSR: SBRSELEN Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ + #define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ + #define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ + #define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ + #define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ + #define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ + #define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ + #define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ + #define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + + #define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ + #define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ + #define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ + #define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + #define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ + #define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ + #define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ + #define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE ) /*!< Core Debug configuration struct */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ + #endif + + #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SAU_BASE (SCS_BASE + 0x0DD0UL) /*!< Security Attribution Unit */ + #define SAU ((SAU_Type *) SAU_BASE ) /*!< Security Attribution Unit */ + #endif + + #define FPU_BASE (SCS_BASE + 0x0F30UL) /*!< Floating Point Unit */ + #define FPU ((FPU_Type *) FPU_BASE ) /*!< Floating Point Unit */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SCS_BASE_NS (0xE002E000UL) /*!< System Control Space Base Address (non-secure address space) */ + #define CoreDebug_BASE_NS (0xE002EDF0UL) /*!< Core Debug Base Address (non-secure address space) */ + #define SysTick_BASE_NS (SCS_BASE_NS + 0x0010UL) /*!< SysTick Base Address (non-secure address space) */ + #define NVIC_BASE_NS (SCS_BASE_NS + 0x0100UL) /*!< NVIC Base Address (non-secure address space) */ + #define SCB_BASE_NS (SCS_BASE_NS + 0x0D00UL) /*!< System Control Block Base Address (non-secure address space) */ + + #define SCnSCB_NS ((SCnSCB_Type *) SCS_BASE_NS ) /*!< System control Register not in SCB(non-secure address space) */ + #define SCB_NS ((SCB_Type *) SCB_BASE_NS ) /*!< SCB configuration struct (non-secure address space) */ + #define SysTick_NS ((SysTick_Type *) SysTick_BASE_NS ) /*!< SysTick configuration struct (non-secure address space) */ + #define NVIC_NS ((NVIC_Type *) NVIC_BASE_NS ) /*!< NVIC configuration struct (non-secure address space) */ + #define CoreDebug_NS ((CoreDebug_Type *) CoreDebug_BASE_NS) /*!< Core Debug configuration struct (non-secure address space) */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE_NS (SCS_BASE_NS + 0x0D90UL) /*!< Memory Protection Unit (non-secure address space) */ + #define MPU_NS ((MPU_Type *) MPU_BASE_NS ) /*!< Memory Protection Unit (non-secure address space) */ + #endif + + #define FPU_BASE_NS (SCS_BASE_NS + 0x0F30UL) /*!< Floating Point Unit (non-secure address space) */ + #define FPU_NS ((FPU_Type *) FPU_BASE_NS ) /*!< Floating Point Unit (non-secure address space) */ + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << 8U) ); /* Insert write key and priorty group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Get Interrupt Target State + \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + \return 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Target State + \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |= ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Clear Interrupt Target State + \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + __DSB(); +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Set Priority Grouping (non-secure) + \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB_NS->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << 8U) ); /* Insert write key and priorty group */ + SCB_NS->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping (non-secure) + \details Reads the priority grouping field from the non-secure NVIC when in secure state. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void) +{ + return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt (non-secure) + \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Interrupt Enable status (non-secure) + \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt (non-secure) + \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Pending Interrupt (non-secure) + \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt (non-secure) + \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt (non-secure) + \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt (non-secure) + \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority (non-secure) + \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every non-secure processor exception. + */ +__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority (non-secure) + \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv8.h" + +#endif + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + uint32_t mvfr0; + + mvfr0 = FPU->MVFR0; + if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U) + { + return 2U; /* Double + Single precision FPU */ + } + else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U) + { + return 1U; /* Single precision FPU */ + } + else + { + return 0U; /* No FPU */ + } +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ########################## SAU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SAUFunctions SAU Functions + \brief Functions that configure the SAU. + @{ + */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + +/** + \brief Enable SAU + \details Enables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Enable(void) +{ + SAU->CTRL |= (SAU_CTRL_ENABLE_Msk); +} + + + +/** + \brief Disable SAU + \details Disables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Disable(void) +{ + SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk); +} + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_SAUFunctions */ + + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief System Tick Configuration (non-secure) + \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function TZ_SysTick_Config_NS is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick_NS->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick_NS->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick_NS->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_ARMV81MML_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mbl.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mbl.h new file mode 100644 index 0000000000..344dca5148 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mbl.h @@ -0,0 +1,1921 @@ +/**************************************************************************//** + * @file core_armv8mbl.h + * @brief CMSIS Armv8-M Baseline Core Peripheral Access Layer Header File + * @version V5.0.8 + * @date 12. November 2018 + ******************************************************************************/ +/* + * Copyright (c) 2009-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_ARMV8MBL_H_GENERIC +#define __CORE_ARMV8MBL_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_ARMv8MBL + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS definitions */ +#define __ARMv8MBL_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __ARMv8MBL_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __ARMv8MBL_CMSIS_VERSION ((__ARMv8MBL_CMSIS_VERSION_MAIN << 16U) | \ + __ARMv8MBL_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M ( 2U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_ARMV8MBL_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_ARMV8MBL_H_DEPENDANT +#define __CORE_ARMV8MBL_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __ARMv8MBL_REV + #define __ARMv8MBL_REV 0x0000U + #warning "__ARMv8MBL_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __SAUREGION_PRESENT + #define __SAUREGION_PRESENT 0U + #warning "__SAUREGION_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __VTOR_PRESENT + #define __VTOR_PRESENT 0U + #warning "__VTOR_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif + + #ifndef __ETM_PRESENT + #define __ETM_PRESENT 0U + #warning "__ETM_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MTB_PRESENT + #define __MTB_PRESENT 0U + #warning "__MTB_PRESENT not defined in device header file; using default!" + #endif + +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group ARMv8MBL */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core SAU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:28; /*!< bit: 0..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t _reserved1:3; /*!< bit: 25..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack-pointer select */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[16U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[16U]; + __IOM uint32_t ICER[16U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[16U]; + __IOM uint32_t ISPR[16U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[16U]; + __IOM uint32_t ICPR[16U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[16U]; + __IOM uint32_t IABR[16U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[16U]; + __IOM uint32_t ITNS[16U]; /*!< Offset: 0x280 (R/W) Interrupt Non-Secure State Register */ + uint32_t RESERVED5[16U]; + __IOM uint32_t IPR[124U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ +#else + uint32_t RESERVED0; +#endif + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED1; + __IOM uint32_t SHPR[2U]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_PENDNMISET_Pos 31U /*!< SCB ICSR: PENDNMISET Position */ +#define SCB_ICSR_PENDNMISET_Msk (1UL << SCB_ICSR_PENDNMISET_Pos) /*!< SCB ICSR: PENDNMISET Mask */ + +#define SCB_ICSR_NMIPENDSET_Pos SCB_ICSR_PENDNMISET_Pos /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */ +#define SCB_ICSR_NMIPENDSET_Msk SCB_ICSR_PENDNMISET_Msk /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */ + +#define SCB_ICSR_PENDNMICLR_Pos 30U /*!< SCB ICSR: PENDNMICLR Position */ +#define SCB_ICSR_PENDNMICLR_Msk (1UL << SCB_ICSR_PENDNMICLR_Pos) /*!< SCB ICSR: PENDNMICLR Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_STTNS_Pos 24U /*!< SCB ICSR: STTNS Position (Security Extension) */ +#define SCB_ICSR_STTNS_Msk (1UL << SCB_ICSR_STTNS_Pos) /*!< SCB ICSR: STTNS Mask (Security Extension) */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ +#endif + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIS_Pos 14U /*!< SCB AIRCR: PRIS Position */ +#define SCB_AIRCR_PRIS_Msk (1UL << SCB_AIRCR_PRIS_Pos) /*!< SCB AIRCR: PRIS Mask */ + +#define SCB_AIRCR_BFHFNMINS_Pos 13U /*!< SCB AIRCR: BFHFNMINS Position */ +#define SCB_AIRCR_BFHFNMINS_Msk (1UL << SCB_AIRCR_BFHFNMINS_Pos) /*!< SCB AIRCR: BFHFNMINS Mask */ + +#define SCB_AIRCR_SYSRESETREQS_Pos 3U /*!< SCB AIRCR: SYSRESETREQS Position */ +#define SCB_AIRCR_SYSRESETREQS_Msk (1UL << SCB_AIRCR_SYSRESETREQS_Pos) /*!< SCB AIRCR: SYSRESETREQS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEPS_Pos 3U /*!< SCB SCR: SLEEPDEEPS Position */ +#define SCB_SCR_SLEEPDEEPS_Msk (1UL << SCB_SCR_SLEEPDEEPS_Pos) /*!< SCB SCR: SLEEPDEEPS Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_BP_Pos 18U /*!< SCB CCR: BP Position */ +#define SCB_CCR_BP_Msk (1UL << SCB_CCR_BP_Pos) /*!< SCB CCR: BP Mask */ + +#define SCB_CCR_IC_Pos 17U /*!< SCB CCR: IC Position */ +#define SCB_CCR_IC_Msk (1UL << SCB_CCR_IC_Pos) /*!< SCB CCR: IC Mask */ + +#define SCB_CCR_DC_Pos 16U /*!< SCB CCR: DC Position */ +#define SCB_CCR_DC_Msk (1UL << SCB_CCR_DC_Pos) /*!< SCB CCR: DC Mask */ + +#define SCB_CCR_STKOFHFNMIGN_Pos 10U /*!< SCB CCR: STKOFHFNMIGN Position */ +#define SCB_CCR_STKOFHFNMIGN_Msk (1UL << SCB_CCR_STKOFHFNMIGN_Pos) /*!< SCB CCR: STKOFHFNMIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_HARDFAULTPENDED_Pos 21U /*!< SCB SHCSR: HARDFAULTPENDED Position */ +#define SCB_SHCSR_HARDFAULTPENDED_Msk (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos) /*!< SCB SHCSR: HARDFAULTPENDED Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_NMIACT_Pos 5U /*!< SCB SHCSR: NMIACT Position */ +#define SCB_SHCSR_NMIACT_Msk (1UL << SCB_SHCSR_NMIACT_Pos) /*!< SCB SHCSR: NMIACT Mask */ + +#define SCB_SHCSR_HARDFAULTACT_Pos 2U /*!< SCB SHCSR: HARDFAULTACT Position */ +#define SCB_SHCSR_HARDFAULTACT_Msk (1UL << SCB_SHCSR_HARDFAULTACT_Pos) /*!< SCB SHCSR: HARDFAULTACT Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + uint32_t RESERVED0[6U]; + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + uint32_t RESERVED3[1U]; + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED4[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + uint32_t RESERVED5[1U]; + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED6[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + uint32_t RESERVED7[1U]; + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ + uint32_t RESERVED8[1U]; + __IOM uint32_t COMP4; /*!< Offset: 0x060 (R/W) Comparator Register 4 */ + uint32_t RESERVED9[1U]; + __IOM uint32_t FUNCTION4; /*!< Offset: 0x068 (R/W) Function Register 4 */ + uint32_t RESERVED10[1U]; + __IOM uint32_t COMP5; /*!< Offset: 0x070 (R/W) Comparator Register 5 */ + uint32_t RESERVED11[1U]; + __IOM uint32_t FUNCTION5; /*!< Offset: 0x078 (R/W) Function Register 5 */ + uint32_t RESERVED12[1U]; + __IOM uint32_t COMP6; /*!< Offset: 0x080 (R/W) Comparator Register 6 */ + uint32_t RESERVED13[1U]; + __IOM uint32_t FUNCTION6; /*!< Offset: 0x088 (R/W) Function Register 6 */ + uint32_t RESERVED14[1U]; + __IOM uint32_t COMP7; /*!< Offset: 0x090 (R/W) Comparator Register 7 */ + uint32_t RESERVED15[1U]; + __IOM uint32_t FUNCTION7; /*!< Offset: 0x098 (R/W) Function Register 7 */ + uint32_t RESERVED16[1U]; + __IOM uint32_t COMP8; /*!< Offset: 0x0A0 (R/W) Comparator Register 8 */ + uint32_t RESERVED17[1U]; + __IOM uint32_t FUNCTION8; /*!< Offset: 0x0A8 (R/W) Function Register 8 */ + uint32_t RESERVED18[1U]; + __IOM uint32_t COMP9; /*!< Offset: 0x0B0 (R/W) Comparator Register 9 */ + uint32_t RESERVED19[1U]; + __IOM uint32_t FUNCTION9; /*!< Offset: 0x0B8 (R/W) Function Register 9 */ + uint32_t RESERVED20[1U]; + __IOM uint32_t COMP10; /*!< Offset: 0x0C0 (R/W) Comparator Register 10 */ + uint32_t RESERVED21[1U]; + __IOM uint32_t FUNCTION10; /*!< Offset: 0x0C8 (R/W) Function Register 10 */ + uint32_t RESERVED22[1U]; + __IOM uint32_t COMP11; /*!< Offset: 0x0D0 (R/W) Comparator Register 11 */ + uint32_t RESERVED23[1U]; + __IOM uint32_t FUNCTION11; /*!< Offset: 0x0D8 (R/W) Function Register 11 */ + uint32_t RESERVED24[1U]; + __IOM uint32_t COMP12; /*!< Offset: 0x0E0 (R/W) Comparator Register 12 */ + uint32_t RESERVED25[1U]; + __IOM uint32_t FUNCTION12; /*!< Offset: 0x0E8 (R/W) Function Register 12 */ + uint32_t RESERVED26[1U]; + __IOM uint32_t COMP13; /*!< Offset: 0x0F0 (R/W) Comparator Register 13 */ + uint32_t RESERVED27[1U]; + __IOM uint32_t FUNCTION13; /*!< Offset: 0x0F8 (R/W) Function Register 13 */ + uint32_t RESERVED28[1U]; + __IOM uint32_t COMP14; /*!< Offset: 0x100 (R/W) Comparator Register 14 */ + uint32_t RESERVED29[1U]; + __IOM uint32_t FUNCTION14; /*!< Offset: 0x108 (R/W) Function Register 14 */ + uint32_t RESERVED30[1U]; + __IOM uint32_t COMP15; /*!< Offset: 0x110 (R/W) Comparator Register 15 */ + uint32_t RESERVED31[1U]; + __IOM uint32_t FUNCTION15; /*!< Offset: 0x118 (R/W) Function Register 15 */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_ID_Pos 27U /*!< DWT FUNCTION: ID Position */ +#define DWT_FUNCTION_ID_Msk (0x1FUL << DWT_FUNCTION_ID_Pos) /*!< DWT FUNCTION: ID Mask */ + +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_ACTION_Pos 4U /*!< DWT FUNCTION: ACTION Position */ +#define DWT_FUNCTION_ACTION_Msk (0x3UL << DWT_FUNCTION_ACTION_Pos) /*!< DWT FUNCTION: ACTION Mask */ + +#define DWT_FUNCTION_MATCH_Pos 0U /*!< DWT FUNCTION: MATCH Position */ +#define DWT_FUNCTION_MATCH_Msk (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/) /*!< DWT FUNCTION: MATCH Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Sizes Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Sizes Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IOM uint32_t PSCR; /*!< Offset: 0x308 (R/W) Periodic Synchronization Control Register */ + uint32_t RESERVED3[809U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) Software Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) Software Lock Status Register */ + uint32_t RESERVED4[4U]; + __IM uint32_t TYPE; /*!< Offset: 0xFC8 (R/ ) Device Identifier Register */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) Device Type Register */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_SWOSCALER_Pos 0U /*!< TPI ACPR: SWOSCALER Position */ +#define TPI_ACPR_SWOSCALER_Msk (0xFFFFUL /*<< TPI_ACPR_SWOSCALER_Pos*/) /*!< TPI ACPR: SWOSCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_FOnMan_Pos 6U /*!< TPI FFCR: FOnMan Position */ +#define TPI_FFCR_FOnMan_Msk (0x1UL << TPI_FFCR_FOnMan_Pos) /*!< TPI FFCR: FOnMan Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI Periodic Synchronization Control Register Definitions */ +#define TPI_PSCR_PSCount_Pos 0U /*!< TPI PSCR: PSCount Position */ +#define TPI_PSCR_PSCount_Msk (0x1FUL /*<< TPI_PSCR_PSCount_Pos*/) /*!< TPI PSCR: TPSCount Mask */ + +/* TPI Software Lock Status Register Definitions */ +#define TPI_LSR_nTT_Pos 1U /*!< TPI LSR: Not thirty-two bit. Position */ +#define TPI_LSR_nTT_Msk (0x1UL << TPI_LSR_nTT_Pos) /*!< TPI LSR: Not thirty-two bit. Mask */ + +#define TPI_LSR_SLK_Pos 1U /*!< TPI LSR: Software Lock status Position */ +#define TPI_LSR_SLK_Msk (0x1UL << TPI_LSR_SLK_Pos) /*!< TPI LSR: Software Lock status Mask */ + +#define TPI_LSR_SLI_Pos 0U /*!< TPI LSR: Software Lock implemented Position */ +#define TPI_LSR_SLI_Msk (0x1UL /*<< TPI_LSR_SLI_Pos*/) /*!< TPI LSR: Software Lock implemented Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_FIFOSZ_Pos 6U /*!< TPI DEVID: FIFO depth Position */ +#define TPI_DEVID_FIFOSZ_Msk (0x7UL << TPI_DEVID_FIFOSZ_Pos) /*!< TPI DEVID: FIFO depth Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) MPU Region Limit Address Register */ + uint32_t RESERVED0[7U]; + union { + __IOM uint32_t MAIR[2]; + struct { + __IOM uint32_t MAIR0; /*!< Offset: 0x030 (R/W) MPU Memory Attribute Indirection Register 0 */ + __IOM uint32_t MAIR1; /*!< Offset: 0x034 (R/W) MPU Memory Attribute Indirection Register 1 */ + }; + }; +} MPU_Type; + +#define MPU_TYPE_RALIASES 1U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_BASE_Pos 5U /*!< MPU RBAR: BASE Position */ +#define MPU_RBAR_BASE_Msk (0x7FFFFFFUL << MPU_RBAR_BASE_Pos) /*!< MPU RBAR: BASE Mask */ + +#define MPU_RBAR_SH_Pos 3U /*!< MPU RBAR: SH Position */ +#define MPU_RBAR_SH_Msk (0x3UL << MPU_RBAR_SH_Pos) /*!< MPU RBAR: SH Mask */ + +#define MPU_RBAR_AP_Pos 1U /*!< MPU RBAR: AP Position */ +#define MPU_RBAR_AP_Msk (0x3UL << MPU_RBAR_AP_Pos) /*!< MPU RBAR: AP Mask */ + +#define MPU_RBAR_XN_Pos 0U /*!< MPU RBAR: XN Position */ +#define MPU_RBAR_XN_Msk (01UL /*<< MPU_RBAR_XN_Pos*/) /*!< MPU RBAR: XN Mask */ + +/* MPU Region Limit Address Register Definitions */ +#define MPU_RLAR_LIMIT_Pos 5U /*!< MPU RLAR: LIMIT Position */ +#define MPU_RLAR_LIMIT_Msk (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos) /*!< MPU RLAR: LIMIT Mask */ + +#define MPU_RLAR_AttrIndx_Pos 1U /*!< MPU RLAR: AttrIndx Position */ +#define MPU_RLAR_AttrIndx_Msk (0x7UL << MPU_RLAR_AttrIndx_Pos) /*!< MPU RLAR: AttrIndx Mask */ + +#define MPU_RLAR_EN_Pos 0U /*!< MPU RLAR: EN Position */ +#define MPU_RLAR_EN_Msk (1UL /*<< MPU_RLAR_EN_Pos*/) /*!< MPU RLAR: EN Mask */ + +/* MPU Memory Attribute Indirection Register 0 Definitions */ +#define MPU_MAIR0_Attr3_Pos 24U /*!< MPU MAIR0: Attr3 Position */ +#define MPU_MAIR0_Attr3_Msk (0xFFUL << MPU_MAIR0_Attr3_Pos) /*!< MPU MAIR0: Attr3 Mask */ + +#define MPU_MAIR0_Attr2_Pos 16U /*!< MPU MAIR0: Attr2 Position */ +#define MPU_MAIR0_Attr2_Msk (0xFFUL << MPU_MAIR0_Attr2_Pos) /*!< MPU MAIR0: Attr2 Mask */ + +#define MPU_MAIR0_Attr1_Pos 8U /*!< MPU MAIR0: Attr1 Position */ +#define MPU_MAIR0_Attr1_Msk (0xFFUL << MPU_MAIR0_Attr1_Pos) /*!< MPU MAIR0: Attr1 Mask */ + +#define MPU_MAIR0_Attr0_Pos 0U /*!< MPU MAIR0: Attr0 Position */ +#define MPU_MAIR0_Attr0_Msk (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/) /*!< MPU MAIR0: Attr0 Mask */ + +/* MPU Memory Attribute Indirection Register 1 Definitions */ +#define MPU_MAIR1_Attr7_Pos 24U /*!< MPU MAIR1: Attr7 Position */ +#define MPU_MAIR1_Attr7_Msk (0xFFUL << MPU_MAIR1_Attr7_Pos) /*!< MPU MAIR1: Attr7 Mask */ + +#define MPU_MAIR1_Attr6_Pos 16U /*!< MPU MAIR1: Attr6 Position */ +#define MPU_MAIR1_Attr6_Msk (0xFFUL << MPU_MAIR1_Attr6_Pos) /*!< MPU MAIR1: Attr6 Mask */ + +#define MPU_MAIR1_Attr5_Pos 8U /*!< MPU MAIR1: Attr5 Position */ +#define MPU_MAIR1_Attr5_Msk (0xFFUL << MPU_MAIR1_Attr5_Pos) /*!< MPU MAIR1: Attr5 Mask */ + +#define MPU_MAIR1_Attr4_Pos 0U /*!< MPU MAIR1: Attr4 Position */ +#define MPU_MAIR1_Attr4_Msk (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/) /*!< MPU MAIR1: Attr4 Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SAU Security Attribution Unit (SAU) + \brief Type definitions for the Security Attribution Unit (SAU) + @{ + */ + +/** + \brief Structure type to access the Security Attribution Unit (SAU). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SAU Control Register */ + __IM uint32_t TYPE; /*!< Offset: 0x004 (R/ ) SAU Type Register */ +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) SAU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) SAU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) SAU Region Limit Address Register */ +#endif +} SAU_Type; + +/* SAU Control Register Definitions */ +#define SAU_CTRL_ALLNS_Pos 1U /*!< SAU CTRL: ALLNS Position */ +#define SAU_CTRL_ALLNS_Msk (1UL << SAU_CTRL_ALLNS_Pos) /*!< SAU CTRL: ALLNS Mask */ + +#define SAU_CTRL_ENABLE_Pos 0U /*!< SAU CTRL: ENABLE Position */ +#define SAU_CTRL_ENABLE_Msk (1UL /*<< SAU_CTRL_ENABLE_Pos*/) /*!< SAU CTRL: ENABLE Mask */ + +/* SAU Type Register Definitions */ +#define SAU_TYPE_SREGION_Pos 0U /*!< SAU TYPE: SREGION Position */ +#define SAU_TYPE_SREGION_Msk (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/) /*!< SAU TYPE: SREGION Mask */ + +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) +/* SAU Region Number Register Definitions */ +#define SAU_RNR_REGION_Pos 0U /*!< SAU RNR: REGION Position */ +#define SAU_RNR_REGION_Msk (0xFFUL /*<< SAU_RNR_REGION_Pos*/) /*!< SAU RNR: REGION Mask */ + +/* SAU Region Base Address Register Definitions */ +#define SAU_RBAR_BADDR_Pos 5U /*!< SAU RBAR: BADDR Position */ +#define SAU_RBAR_BADDR_Msk (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos) /*!< SAU RBAR: BADDR Mask */ + +/* SAU Region Limit Address Register Definitions */ +#define SAU_RLAR_LADDR_Pos 5U /*!< SAU RLAR: LADDR Position */ +#define SAU_RLAR_LADDR_Msk (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos) /*!< SAU RLAR: LADDR Mask */ + +#define SAU_RLAR_NSC_Pos 1U /*!< SAU RLAR: NSC Position */ +#define SAU_RLAR_NSC_Msk (1UL << SAU_RLAR_NSC_Pos) /*!< SAU RLAR: NSC Mask */ + +#define SAU_RLAR_ENABLE_Pos 0U /*!< SAU RLAR: ENABLE Position */ +#define SAU_RLAR_ENABLE_Msk (1UL /*<< SAU_RLAR_ENABLE_Pos*/) /*!< SAU RLAR: ENABLE Mask */ + +#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */ + +/*@} end of group CMSIS_SAU */ +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ + uint32_t RESERVED4[1U]; + __IOM uint32_t DAUTHCTRL; /*!< Offset: 0x014 (R/W) Debug Authentication Control Register */ + __IOM uint32_t DSCSR; /*!< Offset: 0x018 (R/W) Debug Security Control and Status Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESTART_ST_Pos 26U /*!< CoreDebug DHCSR: S_RESTART_ST Position */ +#define CoreDebug_DHCSR_S_RESTART_ST_Msk (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos) /*!< CoreDebug DHCSR: S_RESTART_ST Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register */ +#define CoreDebug_DEMCR_DWTENA_Pos 24U /*!< CoreDebug DEMCR: DWTENA Position */ +#define CoreDebug_DEMCR_DWTENA_Msk (1UL << CoreDebug_DEMCR_DWTENA_Pos) /*!< CoreDebug DEMCR: DWTENA Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/* Debug Authentication Control Register Definitions */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos 3U /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */ + +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos 2U /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos) /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */ + +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos 1U /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */ +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */ + +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos 0U /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */ + +/* Debug Security Control and Status Register Definitions */ +#define CoreDebug_DSCSR_CDS_Pos 16U /*!< CoreDebug DSCSR: CDS Position */ +#define CoreDebug_DSCSR_CDS_Msk (1UL << CoreDebug_DSCSR_CDS_Pos) /*!< CoreDebug DSCSR: CDS Mask */ + +#define CoreDebug_DSCSR_SBRSEL_Pos 1U /*!< CoreDebug DSCSR: SBRSEL Position */ +#define CoreDebug_DSCSR_SBRSEL_Msk (1UL << CoreDebug_DSCSR_SBRSEL_Pos) /*!< CoreDebug DSCSR: SBRSEL Mask */ + +#define CoreDebug_DSCSR_SBRSELEN_Pos 0U /*!< CoreDebug DSCSR: SBRSELEN Position */ +#define CoreDebug_DSCSR_SBRSELEN_Msk (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/) /*!< CoreDebug DSCSR: SBRSELEN Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ + #define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ + #define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ + #define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ + #define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ + #define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ + #define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ + #define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + + + #define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ + #define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ + #define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + #define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ + #define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ + #define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE ) /*!< Core Debug configuration struct */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ + #endif + + #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SAU_BASE (SCS_BASE + 0x0DD0UL) /*!< Security Attribution Unit */ + #define SAU ((SAU_Type *) SAU_BASE ) /*!< Security Attribution Unit */ + #endif + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SCS_BASE_NS (0xE002E000UL) /*!< System Control Space Base Address (non-secure address space) */ + #define CoreDebug_BASE_NS (0xE002EDF0UL) /*!< Core Debug Base Address (non-secure address space) */ + #define SysTick_BASE_NS (SCS_BASE_NS + 0x0010UL) /*!< SysTick Base Address (non-secure address space) */ + #define NVIC_BASE_NS (SCS_BASE_NS + 0x0100UL) /*!< NVIC Base Address (non-secure address space) */ + #define SCB_BASE_NS (SCS_BASE_NS + 0x0D00UL) /*!< System Control Block Base Address (non-secure address space) */ + + #define SCB_NS ((SCB_Type *) SCB_BASE_NS ) /*!< SCB configuration struct (non-secure address space) */ + #define SysTick_NS ((SysTick_Type *) SysTick_BASE_NS ) /*!< SysTick configuration struct (non-secure address space) */ + #define NVIC_NS ((NVIC_Type *) NVIC_BASE_NS ) /*!< NVIC configuration struct (non-secure address space) */ + #define CoreDebug_NS ((CoreDebug_Type *) CoreDebug_BASE_NS) /*!< Core Debug configuration struct (non-secure address space) */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE_NS (SCS_BASE_NS + 0x0D90UL) /*!< Memory Protection Unit (non-secure address space) */ + #define MPU_NS ((MPU_Type *) MPU_BASE_NS ) /*!< Memory Protection Unit (non-secure address space) */ + #endif + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* Special LR values for Secure/Non-Secure call handling and exception handling */ + +/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS */ +#define FNC_RETURN (0xFEFFFFFFUL) /* bit [0] ignored when processing a branch */ + +/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */ +#define EXC_RETURN_PREFIX (0xFF000000UL) /* bits [31:24] set to indicate an EXC_RETURN value */ +#define EXC_RETURN_S (0x00000040UL) /* bit [6] stack used to push registers: 0=Non-secure 1=Secure */ +#define EXC_RETURN_DCRS (0x00000020UL) /* bit [5] stacking rules for called registers: 0=skipped 1=saved */ +#define EXC_RETURN_FTYPE (0x00000010UL) /* bit [4] allocate stack for floating-point context: 0=done 1=skipped */ +#define EXC_RETURN_MODE (0x00000008UL) /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode */ +#define EXC_RETURN_SPSEL (0x00000004UL) /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP */ +#define EXC_RETURN_ES (0x00000001UL) /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */ + +/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking */ +#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) /* Value for processors with floating-point extension: */ +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125AUL) /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE */ +#else +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125BUL) /* Value for processors without floating-point extension */ +#endif + + +/* Interrupt Priorities are WORD accessible only under Armv6-M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( ((((uint32_t)(int32_t)(IRQn)) ) & 0x03UL) * 8UL) +#define _SHP_IDX(IRQn) ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >> 2UL) ) +#define _IP_IDX(IRQn) ( (((uint32_t)(int32_t)(IRQn)) >> 2UL) ) + +#define __NVIC_SetPriorityGrouping(X) (void)(X) +#define __NVIC_GetPriorityGrouping() (0U) + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Get Interrupt Target State + \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + \return 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Target State + \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |= ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Clear Interrupt Target State + \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IPR[_IP_IDX(IRQn)] = ((uint32_t)(NVIC->IPR[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + If VTOR is not present address 0 must be mapped to SRAM. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + uint32_t *vectors = (uint32_t *)SCB->VTOR; +#else + uint32_t *vectors = (uint32_t *)0x0U; +#endif + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + __DSB(); +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + uint32_t *vectors = (uint32_t *)SCB->VTOR; +#else + uint32_t *vectors = (uint32_t *)0x0U; +#endif + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Enable Interrupt (non-secure) + \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Interrupt Enable status (non-secure) + \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt (non-secure) + \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Pending Interrupt (non-secure) + \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt (non-secure) + \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt (non-secure) + \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt (non-secure) + \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority (non-secure) + \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every non-secure processor exception. + */ +__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->IPR[_IP_IDX(IRQn)] = ((uint32_t)(NVIC_NS->IPR[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB_NS->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB_NS->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority (non-secure) + \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB_NS->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv8.h" + +#endif + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ########################## SAU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SAUFunctions SAU Functions + \brief Functions that configure the SAU. + @{ + */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + +/** + \brief Enable SAU + \details Enables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Enable(void) +{ + SAU->CTRL |= (SAU_CTRL_ENABLE_Msk); +} + + + +/** + \brief Disable SAU + \details Disables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Disable(void) +{ + SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk); +} + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_SAUFunctions */ + + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief System Tick Configuration (non-secure) + \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function TZ_SysTick_Config_NS is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick_NS->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick_NS->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick_NS->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_ARMV8MBL_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mml.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mml.h new file mode 100644 index 0000000000..5ddb8aeda7 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_armv8mml.h @@ -0,0 +1,2835 @@ +/**************************************************************************//** + * @file core_armv8mml.h + * @brief CMSIS Armv8-M Mainline Core Peripheral Access Layer Header File + * @version V5.1.0 + * @date 12. September 2018 + ******************************************************************************/ +/* + * Copyright (c) 2009-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_ARMV8MML_H_GENERIC +#define __CORE_ARMV8MML_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_ARMv8MML + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS Armv8MML definitions */ +#define __ARMv8MML_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __ARMv8MML_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __ARMv8MML_CMSIS_VERSION ((__ARMv8MML_CMSIS_VERSION_MAIN << 16U) | \ + __ARMv8MML_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (81U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions. +*/ +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined(__ARM_FEATURE_DSP) + #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_ARMV8MML_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_ARMV8MML_H_DEPENDANT +#define __CORE_ARMV8MML_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __ARMv8MML_REV + #define __ARMv8MML_REV 0x0000U + #warning "__ARMv8MML_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __SAUREGION_PRESENT + #define __SAUREGION_PRESENT 0U + #warning "__SAUREGION_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __DSP_PRESENT + #define __DSP_PRESENT 0U + #warning "__DSP_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group ARMv8MML */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core SAU Register + - Core FPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + +#define APSR_GE_Pos 16U /*!< APSR: GE Position */ +#define APSR_GE_Msk (0xFUL << APSR_GE_Pos) /*!< APSR: GE Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:7; /*!< bit: 9..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t IT:2; /*!< bit: 25..26 saved IT state (read 0) */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_IT_Pos 25U /*!< xPSR: IT Position */ +#define xPSR_IT_Msk (3UL << xPSR_IT_Pos) /*!< xPSR: IT Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_GE_Pos 16U /*!< xPSR: GE Position */ +#define xPSR_GE_Msk (0xFUL << xPSR_GE_Pos) /*!< xPSR: GE Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack-pointer select */ + uint32_t FPCA:1; /*!< bit: 2 Floating-point context active */ + uint32_t SFPA:1; /*!< bit: 3 Secure floating-point active */ + uint32_t _reserved1:28; /*!< bit: 4..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SFPA_Pos 3U /*!< CONTROL: SFPA Position */ +#define CONTROL_SFPA_Msk (1UL << CONTROL_SFPA_Pos) /*!< CONTROL: SFPA Mask */ + +#define CONTROL_FPCA_Pos 2U /*!< CONTROL: FPCA Position */ +#define CONTROL_FPCA_Msk (1UL << CONTROL_FPCA_Pos) /*!< CONTROL: FPCA Mask */ + +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[16U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[16U]; + __IOM uint32_t ICER[16U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[16U]; + __IOM uint32_t ISPR[16U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[16U]; + __IOM uint32_t ICPR[16U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[16U]; + __IOM uint32_t IABR[16U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[16U]; + __IOM uint32_t ITNS[16U]; /*!< Offset: 0x280 (R/W) Interrupt Non-Secure State Register */ + uint32_t RESERVED5[16U]; + __IOM uint8_t IPR[496U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED6[580U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHPR[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t ID_PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t ID_DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ID_ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t ID_MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ID_ISAR[6U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + __IM uint32_t CLIDR; /*!< Offset: 0x078 (R/ ) Cache Level ID register */ + __IM uint32_t CTR; /*!< Offset: 0x07C (R/ ) Cache Type register */ + __IM uint32_t CCSIDR; /*!< Offset: 0x080 (R/ ) Cache Size ID Register */ + __IOM uint32_t CSSELR; /*!< Offset: 0x084 (R/W) Cache Size Selection Register */ + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ + __IOM uint32_t NSACR; /*!< Offset: 0x08C (R/W) Non-Secure Access Control Register */ + uint32_t RESERVED3[92U]; + __OM uint32_t STIR; /*!< Offset: 0x200 ( /W) Software Triggered Interrupt Register */ + uint32_t RESERVED4[15U]; + __IM uint32_t MVFR0; /*!< Offset: 0x240 (R/ ) Media and VFP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x244 (R/ ) Media and VFP Feature Register 1 */ + __IM uint32_t MVFR2; /*!< Offset: 0x248 (R/ ) Media and VFP Feature Register 2 */ + uint32_t RESERVED5[1U]; + __OM uint32_t ICIALLU; /*!< Offset: 0x250 ( /W) I-Cache Invalidate All to PoU */ + uint32_t RESERVED6[1U]; + __OM uint32_t ICIMVAU; /*!< Offset: 0x258 ( /W) I-Cache Invalidate by MVA to PoU */ + __OM uint32_t DCIMVAC; /*!< Offset: 0x25C ( /W) D-Cache Invalidate by MVA to PoC */ + __OM uint32_t DCISW; /*!< Offset: 0x260 ( /W) D-Cache Invalidate by Set-way */ + __OM uint32_t DCCMVAU; /*!< Offset: 0x264 ( /W) D-Cache Clean by MVA to PoU */ + __OM uint32_t DCCMVAC; /*!< Offset: 0x268 ( /W) D-Cache Clean by MVA to PoC */ + __OM uint32_t DCCSW; /*!< Offset: 0x26C ( /W) D-Cache Clean by Set-way */ + __OM uint32_t DCCIMVAC; /*!< Offset: 0x270 ( /W) D-Cache Clean and Invalidate by MVA to PoC */ + __OM uint32_t DCCISW; /*!< Offset: 0x274 ( /W) D-Cache Clean and Invalidate by Set-way */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_PENDNMISET_Pos 31U /*!< SCB ICSR: PENDNMISET Position */ +#define SCB_ICSR_PENDNMISET_Msk (1UL << SCB_ICSR_PENDNMISET_Pos) /*!< SCB ICSR: PENDNMISET Mask */ + +#define SCB_ICSR_NMIPENDSET_Pos SCB_ICSR_PENDNMISET_Pos /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */ +#define SCB_ICSR_NMIPENDSET_Msk SCB_ICSR_PENDNMISET_Msk /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */ + +#define SCB_ICSR_PENDNMICLR_Pos 30U /*!< SCB ICSR: PENDNMICLR Position */ +#define SCB_ICSR_PENDNMICLR_Msk (1UL << SCB_ICSR_PENDNMICLR_Pos) /*!< SCB ICSR: PENDNMICLR Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_STTNS_Pos 24U /*!< SCB ICSR: STTNS Position (Security Extension) */ +#define SCB_ICSR_STTNS_Msk (1UL << SCB_ICSR_STTNS_Pos) /*!< SCB ICSR: STTNS Mask (Security Extension) */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIS_Pos 14U /*!< SCB AIRCR: PRIS Position */ +#define SCB_AIRCR_PRIS_Msk (1UL << SCB_AIRCR_PRIS_Pos) /*!< SCB AIRCR: PRIS Mask */ + +#define SCB_AIRCR_BFHFNMINS_Pos 13U /*!< SCB AIRCR: BFHFNMINS Position */ +#define SCB_AIRCR_BFHFNMINS_Msk (1UL << SCB_AIRCR_BFHFNMINS_Pos) /*!< SCB AIRCR: BFHFNMINS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQS_Pos 3U /*!< SCB AIRCR: SYSRESETREQS Position */ +#define SCB_AIRCR_SYSRESETREQS_Msk (1UL << SCB_AIRCR_SYSRESETREQS_Pos) /*!< SCB AIRCR: SYSRESETREQS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEPS_Pos 3U /*!< SCB SCR: SLEEPDEEPS Position */ +#define SCB_SCR_SLEEPDEEPS_Msk (1UL << SCB_SCR_SLEEPDEEPS_Pos) /*!< SCB SCR: SLEEPDEEPS Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_BP_Pos 18U /*!< SCB CCR: BP Position */ +#define SCB_CCR_BP_Msk (1UL << SCB_CCR_BP_Pos) /*!< SCB CCR: BP Mask */ + +#define SCB_CCR_IC_Pos 17U /*!< SCB CCR: IC Position */ +#define SCB_CCR_IC_Msk (1UL << SCB_CCR_IC_Pos) /*!< SCB CCR: IC Mask */ + +#define SCB_CCR_DC_Pos 16U /*!< SCB CCR: DC Position */ +#define SCB_CCR_DC_Msk (1UL << SCB_CCR_DC_Pos) /*!< SCB CCR: DC Mask */ + +#define SCB_CCR_STKOFHFNMIGN_Pos 10U /*!< SCB CCR: STKOFHFNMIGN Position */ +#define SCB_CCR_STKOFHFNMIGN_Msk (1UL << SCB_CCR_STKOFHFNMIGN_Pos) /*!< SCB CCR: STKOFHFNMIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_HARDFAULTPENDED_Pos 21U /*!< SCB SHCSR: HARDFAULTPENDED Position */ +#define SCB_SHCSR_HARDFAULTPENDED_Msk (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos) /*!< SCB SHCSR: HARDFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTPENDED_Pos 20U /*!< SCB SHCSR: SECUREFAULTPENDED Position */ +#define SCB_SHCSR_SECUREFAULTPENDED_Msk (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos) /*!< SCB SHCSR: SECUREFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTENA_Pos 19U /*!< SCB SHCSR: SECUREFAULTENA Position */ +#define SCB_SHCSR_SECUREFAULTENA_Msk (1UL << SCB_SHCSR_SECUREFAULTENA_Pos) /*!< SCB SHCSR: SECUREFAULTENA Mask */ + +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_NMIACT_Pos 5U /*!< SCB SHCSR: NMIACT Position */ +#define SCB_SHCSR_NMIACT_Msk (1UL << SCB_SHCSR_NMIACT_Pos) /*!< SCB SHCSR: NMIACT Mask */ + +#define SCB_SHCSR_SECUREFAULTACT_Pos 4U /*!< SCB SHCSR: SECUREFAULTACT Position */ +#define SCB_SHCSR_SECUREFAULTACT_Msk (1UL << SCB_SHCSR_SECUREFAULTACT_Pos) /*!< SCB SHCSR: SECUREFAULTACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_HARDFAULTACT_Pos 2U /*!< SCB SHCSR: HARDFAULTACT Position */ +#define SCB_SHCSR_HARDFAULTACT_Msk (1UL << SCB_SHCSR_HARDFAULTACT_Pos) /*!< SCB SHCSR: HARDFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MLSPERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 5U) /*!< SCB CFSR (MMFSR): MLSPERR Position */ +#define SCB_CFSR_MLSPERR_Msk (1UL << SCB_CFSR_MLSPERR_Pos) /*!< SCB CFSR (MMFSR): MLSPERR Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_LSPERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 5U) /*!< SCB CFSR (BFSR): LSPERR Position */ +#define SCB_CFSR_LSPERR_Msk (1UL << SCB_CFSR_LSPERR_Pos) /*!< SCB CFSR (BFSR): LSPERR Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_STKOF_Pos (SCB_CFSR_USGFAULTSR_Pos + 4U) /*!< SCB CFSR (UFSR): STKOF Position */ +#define SCB_CFSR_STKOF_Msk (1UL << SCB_CFSR_STKOF_Pos) /*!< SCB CFSR (UFSR): STKOF Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/* SCB Non-Secure Access Control Register Definitions */ +#define SCB_NSACR_CP11_Pos 11U /*!< SCB NSACR: CP11 Position */ +#define SCB_NSACR_CP11_Msk (1UL << SCB_NSACR_CP11_Pos) /*!< SCB NSACR: CP11 Mask */ + +#define SCB_NSACR_CP10_Pos 10U /*!< SCB NSACR: CP10 Position */ +#define SCB_NSACR_CP10_Msk (1UL << SCB_NSACR_CP10_Pos) /*!< SCB NSACR: CP10 Mask */ + +#define SCB_NSACR_CPn_Pos 0U /*!< SCB NSACR: CPn Position */ +#define SCB_NSACR_CPn_Msk (1UL /*<< SCB_NSACR_CPn_Pos*/) /*!< SCB NSACR: CPn Mask */ + +/* SCB Cache Level ID Register Definitions */ +#define SCB_CLIDR_LOUU_Pos 27U /*!< SCB CLIDR: LoUU Position */ +#define SCB_CLIDR_LOUU_Msk (7UL << SCB_CLIDR_LOUU_Pos) /*!< SCB CLIDR: LoUU Mask */ + +#define SCB_CLIDR_LOC_Pos 24U /*!< SCB CLIDR: LoC Position */ +#define SCB_CLIDR_LOC_Msk (7UL << SCB_CLIDR_LOC_Pos) /*!< SCB CLIDR: LoC Mask */ + +/* SCB Cache Type Register Definitions */ +#define SCB_CTR_FORMAT_Pos 29U /*!< SCB CTR: Format Position */ +#define SCB_CTR_FORMAT_Msk (7UL << SCB_CTR_FORMAT_Pos) /*!< SCB CTR: Format Mask */ + +#define SCB_CTR_CWG_Pos 24U /*!< SCB CTR: CWG Position */ +#define SCB_CTR_CWG_Msk (0xFUL << SCB_CTR_CWG_Pos) /*!< SCB CTR: CWG Mask */ + +#define SCB_CTR_ERG_Pos 20U /*!< SCB CTR: ERG Position */ +#define SCB_CTR_ERG_Msk (0xFUL << SCB_CTR_ERG_Pos) /*!< SCB CTR: ERG Mask */ + +#define SCB_CTR_DMINLINE_Pos 16U /*!< SCB CTR: DminLine Position */ +#define SCB_CTR_DMINLINE_Msk (0xFUL << SCB_CTR_DMINLINE_Pos) /*!< SCB CTR: DminLine Mask */ + +#define SCB_CTR_IMINLINE_Pos 0U /*!< SCB CTR: ImInLine Position */ +#define SCB_CTR_IMINLINE_Msk (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/) /*!< SCB CTR: ImInLine Mask */ + +/* SCB Cache Size ID Register Definitions */ +#define SCB_CCSIDR_WT_Pos 31U /*!< SCB CCSIDR: WT Position */ +#define SCB_CCSIDR_WT_Msk (1UL << SCB_CCSIDR_WT_Pos) /*!< SCB CCSIDR: WT Mask */ + +#define SCB_CCSIDR_WB_Pos 30U /*!< SCB CCSIDR: WB Position */ +#define SCB_CCSIDR_WB_Msk (1UL << SCB_CCSIDR_WB_Pos) /*!< SCB CCSIDR: WB Mask */ + +#define SCB_CCSIDR_RA_Pos 29U /*!< SCB CCSIDR: RA Position */ +#define SCB_CCSIDR_RA_Msk (1UL << SCB_CCSIDR_RA_Pos) /*!< SCB CCSIDR: RA Mask */ + +#define SCB_CCSIDR_WA_Pos 28U /*!< SCB CCSIDR: WA Position */ +#define SCB_CCSIDR_WA_Msk (1UL << SCB_CCSIDR_WA_Pos) /*!< SCB CCSIDR: WA Mask */ + +#define SCB_CCSIDR_NUMSETS_Pos 13U /*!< SCB CCSIDR: NumSets Position */ +#define SCB_CCSIDR_NUMSETS_Msk (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos) /*!< SCB CCSIDR: NumSets Mask */ + +#define SCB_CCSIDR_ASSOCIATIVITY_Pos 3U /*!< SCB CCSIDR: Associativity Position */ +#define SCB_CCSIDR_ASSOCIATIVITY_Msk (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos) /*!< SCB CCSIDR: Associativity Mask */ + +#define SCB_CCSIDR_LINESIZE_Pos 0U /*!< SCB CCSIDR: LineSize Position */ +#define SCB_CCSIDR_LINESIZE_Msk (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/) /*!< SCB CCSIDR: LineSize Mask */ + +/* SCB Cache Size Selection Register Definitions */ +#define SCB_CSSELR_LEVEL_Pos 1U /*!< SCB CSSELR: Level Position */ +#define SCB_CSSELR_LEVEL_Msk (7UL << SCB_CSSELR_LEVEL_Pos) /*!< SCB CSSELR: Level Mask */ + +#define SCB_CSSELR_IND_Pos 0U /*!< SCB CSSELR: InD Position */ +#define SCB_CSSELR_IND_Msk (1UL /*<< SCB_CSSELR_IND_Pos*/) /*!< SCB CSSELR: InD Mask */ + +/* SCB Software Triggered Interrupt Register Definitions */ +#define SCB_STIR_INTID_Pos 0U /*!< SCB STIR: INTID Position */ +#define SCB_STIR_INTID_Msk (0x1FFUL /*<< SCB_STIR_INTID_Pos*/) /*!< SCB STIR: INTID Mask */ + +/* SCB D-Cache Invalidate by Set-way Register Definitions */ +#define SCB_DCISW_WAY_Pos 30U /*!< SCB DCISW: Way Position */ +#define SCB_DCISW_WAY_Msk (3UL << SCB_DCISW_WAY_Pos) /*!< SCB DCISW: Way Mask */ + +#define SCB_DCISW_SET_Pos 5U /*!< SCB DCISW: Set Position */ +#define SCB_DCISW_SET_Msk (0x1FFUL << SCB_DCISW_SET_Pos) /*!< SCB DCISW: Set Mask */ + +/* SCB D-Cache Clean by Set-way Register Definitions */ +#define SCB_DCCSW_WAY_Pos 30U /*!< SCB DCCSW: Way Position */ +#define SCB_DCCSW_WAY_Msk (3UL << SCB_DCCSW_WAY_Pos) /*!< SCB DCCSW: Way Mask */ + +#define SCB_DCCSW_SET_Pos 5U /*!< SCB DCCSW: Set Position */ +#define SCB_DCCSW_SET_Msk (0x1FFUL << SCB_DCCSW_SET_Pos) /*!< SCB DCCSW: Set Mask */ + +/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */ +#define SCB_DCCISW_WAY_Pos 30U /*!< SCB DCCISW: Way Position */ +#define SCB_DCCISW_WAY_Msk (3UL << SCB_DCCISW_WAY_Pos) /*!< SCB DCCISW: Way Mask */ + +#define SCB_DCCISW_SET_Pos 5U /*!< SCB DCCISW: Set Position */ +#define SCB_DCCISW_SET_Msk (0x1FFUL << SCB_DCCISW_SET_Pos) /*!< SCB DCCISW: Set Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ + __IOM uint32_t CPPWR; /*!< Offset: 0x00C (R/W) Coprocessor Power Control Register */ +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[32U]; + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) ITM Device Architecture Register */ + uint32_t RESERVED6[4U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Stimulus Port Register Definitions */ +#define ITM_STIM_DISABLED_Pos 1U /*!< ITM STIM: DISABLED Position */ +#define ITM_STIM_DISABLED_Msk (0x1UL << ITM_STIM_DISABLED_Pos) /*!< ITM STIM: DISABLED Mask */ + +#define ITM_STIM_FIFOREADY_Pos 0U /*!< ITM STIM: FIFOREADY Position */ +#define ITM_STIM_FIFOREADY_Msk (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/) /*!< ITM STIM: FIFOREADY Mask */ + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TRACEBUSID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TRACEBUSID_Msk (0x7FUL << ITM_TCR_TRACEBUSID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPRESCALE_Pos 8U /*!< ITM TCR: TSPRESCALE Position */ +#define ITM_TCR_TSPRESCALE_Msk (3UL << ITM_TCR_TSPRESCALE_Pos) /*!< ITM TCR: TSPRESCALE Mask */ + +#define ITM_TCR_STALLENA_Pos 5U /*!< ITM TCR: STALLENA Position */ +#define ITM_TCR_STALLENA_Msk (1UL << ITM_TCR_STALLENA_Pos) /*!< ITM TCR: STALLENA Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + uint32_t RESERVED3[1U]; + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED4[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + uint32_t RESERVED5[1U]; + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED6[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + uint32_t RESERVED7[1U]; + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ + uint32_t RESERVED8[1U]; + __IOM uint32_t COMP4; /*!< Offset: 0x060 (R/W) Comparator Register 4 */ + uint32_t RESERVED9[1U]; + __IOM uint32_t FUNCTION4; /*!< Offset: 0x068 (R/W) Function Register 4 */ + uint32_t RESERVED10[1U]; + __IOM uint32_t COMP5; /*!< Offset: 0x070 (R/W) Comparator Register 5 */ + uint32_t RESERVED11[1U]; + __IOM uint32_t FUNCTION5; /*!< Offset: 0x078 (R/W) Function Register 5 */ + uint32_t RESERVED12[1U]; + __IOM uint32_t COMP6; /*!< Offset: 0x080 (R/W) Comparator Register 6 */ + uint32_t RESERVED13[1U]; + __IOM uint32_t FUNCTION6; /*!< Offset: 0x088 (R/W) Function Register 6 */ + uint32_t RESERVED14[1U]; + __IOM uint32_t COMP7; /*!< Offset: 0x090 (R/W) Comparator Register 7 */ + uint32_t RESERVED15[1U]; + __IOM uint32_t FUNCTION7; /*!< Offset: 0x098 (R/W) Function Register 7 */ + uint32_t RESERVED16[1U]; + __IOM uint32_t COMP8; /*!< Offset: 0x0A0 (R/W) Comparator Register 8 */ + uint32_t RESERVED17[1U]; + __IOM uint32_t FUNCTION8; /*!< Offset: 0x0A8 (R/W) Function Register 8 */ + uint32_t RESERVED18[1U]; + __IOM uint32_t COMP9; /*!< Offset: 0x0B0 (R/W) Comparator Register 9 */ + uint32_t RESERVED19[1U]; + __IOM uint32_t FUNCTION9; /*!< Offset: 0x0B8 (R/W) Function Register 9 */ + uint32_t RESERVED20[1U]; + __IOM uint32_t COMP10; /*!< Offset: 0x0C0 (R/W) Comparator Register 10 */ + uint32_t RESERVED21[1U]; + __IOM uint32_t FUNCTION10; /*!< Offset: 0x0C8 (R/W) Function Register 10 */ + uint32_t RESERVED22[1U]; + __IOM uint32_t COMP11; /*!< Offset: 0x0D0 (R/W) Comparator Register 11 */ + uint32_t RESERVED23[1U]; + __IOM uint32_t FUNCTION11; /*!< Offset: 0x0D8 (R/W) Function Register 11 */ + uint32_t RESERVED24[1U]; + __IOM uint32_t COMP12; /*!< Offset: 0x0E0 (R/W) Comparator Register 12 */ + uint32_t RESERVED25[1U]; + __IOM uint32_t FUNCTION12; /*!< Offset: 0x0E8 (R/W) Function Register 12 */ + uint32_t RESERVED26[1U]; + __IOM uint32_t COMP13; /*!< Offset: 0x0F0 (R/W) Comparator Register 13 */ + uint32_t RESERVED27[1U]; + __IOM uint32_t FUNCTION13; /*!< Offset: 0x0F8 (R/W) Function Register 13 */ + uint32_t RESERVED28[1U]; + __IOM uint32_t COMP14; /*!< Offset: 0x100 (R/W) Comparator Register 14 */ + uint32_t RESERVED29[1U]; + __IOM uint32_t FUNCTION14; /*!< Offset: 0x108 (R/W) Function Register 14 */ + uint32_t RESERVED30[1U]; + __IOM uint32_t COMP15; /*!< Offset: 0x110 (R/W) Comparator Register 15 */ + uint32_t RESERVED31[1U]; + __IOM uint32_t FUNCTION15; /*!< Offset: 0x118 (R/W) Function Register 15 */ + uint32_t RESERVED32[934U]; + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R ) Lock Status Register */ + uint32_t RESERVED33[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) Device Architecture Register */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCDISS_Pos 23U /*!< DWT CTRL: CYCDISS Position */ +#define DWT_CTRL_CYCDISS_Msk (0x1UL << DWT_CTRL_CYCDISS_Pos) /*!< DWT CTRL: CYCDISS Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_ID_Pos 27U /*!< DWT FUNCTION: ID Position */ +#define DWT_FUNCTION_ID_Msk (0x1FUL << DWT_FUNCTION_ID_Pos) /*!< DWT FUNCTION: ID Mask */ + +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_ACTION_Pos 4U /*!< DWT FUNCTION: ACTION Position */ +#define DWT_FUNCTION_ACTION_Msk (0x1UL << DWT_FUNCTION_ACTION_Pos) /*!< DWT FUNCTION: ACTION Mask */ + +#define DWT_FUNCTION_MATCH_Pos 0U /*!< DWT FUNCTION: MATCH Position */ +#define DWT_FUNCTION_MATCH_Msk (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/) /*!< DWT FUNCTION: MATCH Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Sizes Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Sizes Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IOM uint32_t PSCR; /*!< Offset: 0x308 (R/W) Periodic Synchronization Control Register */ + uint32_t RESERVED3[809U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) Software Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) Software Lock Status Register */ + uint32_t RESERVED4[4U]; + __IM uint32_t TYPE; /*!< Offset: 0xFC8 (R/ ) Device Identifier Register */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) Device Type Register */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_SWOSCALER_Pos 0U /*!< TPI ACPR: SWOSCALER Position */ +#define TPI_ACPR_SWOSCALER_Msk (0xFFFFUL /*<< TPI_ACPR_SWOSCALER_Pos*/) /*!< TPI ACPR: SWOSCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_FOnMan_Pos 6U /*!< TPI FFCR: FOnMan Position */ +#define TPI_FFCR_FOnMan_Msk (0x1UL << TPI_FFCR_FOnMan_Pos) /*!< TPI FFCR: FOnMan Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI Periodic Synchronization Control Register Definitions */ +#define TPI_PSCR_PSCount_Pos 0U /*!< TPI PSCR: PSCount Position */ +#define TPI_PSCR_PSCount_Msk (0x1FUL /*<< TPI_PSCR_PSCount_Pos*/) /*!< TPI PSCR: TPSCount Mask */ + +/* TPI Software Lock Status Register Definitions */ +#define TPI_LSR_nTT_Pos 1U /*!< TPI LSR: Not thirty-two bit. Position */ +#define TPI_LSR_nTT_Msk (0x1UL << TPI_LSR_nTT_Pos) /*!< TPI LSR: Not thirty-two bit. Mask */ + +#define TPI_LSR_SLK_Pos 1U /*!< TPI LSR: Software Lock status Position */ +#define TPI_LSR_SLK_Msk (0x1UL << TPI_LSR_SLK_Pos) /*!< TPI LSR: Software Lock status Mask */ + +#define TPI_LSR_SLI_Pos 0U /*!< TPI LSR: Software Lock implemented Position */ +#define TPI_LSR_SLI_Msk (0x1UL /*<< TPI_LSR_SLI_Pos*/) /*!< TPI LSR: Software Lock implemented Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_FIFOSZ_Pos 6U /*!< TPI DEVID: FIFO depth Position */ +#define TPI_DEVID_FIFOSZ_Msk (0x7UL << TPI_DEVID_FIFOSZ_Pos) /*!< TPI DEVID: FIFO depth Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) MPU Region Limit Address Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Region Base Address Register Alias 1 */ + __IOM uint32_t RLAR_A1; /*!< Offset: 0x018 (R/W) MPU Region Limit Address Register Alias 1 */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Region Base Address Register Alias 2 */ + __IOM uint32_t RLAR_A2; /*!< Offset: 0x020 (R/W) MPU Region Limit Address Register Alias 2 */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Region Base Address Register Alias 3 */ + __IOM uint32_t RLAR_A3; /*!< Offset: 0x028 (R/W) MPU Region Limit Address Register Alias 3 */ + uint32_t RESERVED0[1]; + union { + __IOM uint32_t MAIR[2]; + struct { + __IOM uint32_t MAIR0; /*!< Offset: 0x030 (R/W) MPU Memory Attribute Indirection Register 0 */ + __IOM uint32_t MAIR1; /*!< Offset: 0x034 (R/W) MPU Memory Attribute Indirection Register 1 */ + }; + }; +} MPU_Type; + +#define MPU_TYPE_RALIASES 4U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_BASE_Pos 5U /*!< MPU RBAR: BASE Position */ +#define MPU_RBAR_BASE_Msk (0x7FFFFFFUL << MPU_RBAR_BASE_Pos) /*!< MPU RBAR: BASE Mask */ + +#define MPU_RBAR_SH_Pos 3U /*!< MPU RBAR: SH Position */ +#define MPU_RBAR_SH_Msk (0x3UL << MPU_RBAR_SH_Pos) /*!< MPU RBAR: SH Mask */ + +#define MPU_RBAR_AP_Pos 1U /*!< MPU RBAR: AP Position */ +#define MPU_RBAR_AP_Msk (0x3UL << MPU_RBAR_AP_Pos) /*!< MPU RBAR: AP Mask */ + +#define MPU_RBAR_XN_Pos 0U /*!< MPU RBAR: XN Position */ +#define MPU_RBAR_XN_Msk (01UL /*<< MPU_RBAR_XN_Pos*/) /*!< MPU RBAR: XN Mask */ + +/* MPU Region Limit Address Register Definitions */ +#define MPU_RLAR_LIMIT_Pos 5U /*!< MPU RLAR: LIMIT Position */ +#define MPU_RLAR_LIMIT_Msk (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos) /*!< MPU RLAR: LIMIT Mask */ + +#define MPU_RLAR_AttrIndx_Pos 1U /*!< MPU RLAR: AttrIndx Position */ +#define MPU_RLAR_AttrIndx_Msk (0x7UL << MPU_RLAR_AttrIndx_Pos) /*!< MPU RLAR: AttrIndx Mask */ + +#define MPU_RLAR_EN_Pos 0U /*!< MPU RLAR: Region enable bit Position */ +#define MPU_RLAR_EN_Msk (1UL /*<< MPU_RLAR_EN_Pos*/) /*!< MPU RLAR: Region enable bit Disable Mask */ + +/* MPU Memory Attribute Indirection Register 0 Definitions */ +#define MPU_MAIR0_Attr3_Pos 24U /*!< MPU MAIR0: Attr3 Position */ +#define MPU_MAIR0_Attr3_Msk (0xFFUL << MPU_MAIR0_Attr3_Pos) /*!< MPU MAIR0: Attr3 Mask */ + +#define MPU_MAIR0_Attr2_Pos 16U /*!< MPU MAIR0: Attr2 Position */ +#define MPU_MAIR0_Attr2_Msk (0xFFUL << MPU_MAIR0_Attr2_Pos) /*!< MPU MAIR0: Attr2 Mask */ + +#define MPU_MAIR0_Attr1_Pos 8U /*!< MPU MAIR0: Attr1 Position */ +#define MPU_MAIR0_Attr1_Msk (0xFFUL << MPU_MAIR0_Attr1_Pos) /*!< MPU MAIR0: Attr1 Mask */ + +#define MPU_MAIR0_Attr0_Pos 0U /*!< MPU MAIR0: Attr0 Position */ +#define MPU_MAIR0_Attr0_Msk (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/) /*!< MPU MAIR0: Attr0 Mask */ + +/* MPU Memory Attribute Indirection Register 1 Definitions */ +#define MPU_MAIR1_Attr7_Pos 24U /*!< MPU MAIR1: Attr7 Position */ +#define MPU_MAIR1_Attr7_Msk (0xFFUL << MPU_MAIR1_Attr7_Pos) /*!< MPU MAIR1: Attr7 Mask */ + +#define MPU_MAIR1_Attr6_Pos 16U /*!< MPU MAIR1: Attr6 Position */ +#define MPU_MAIR1_Attr6_Msk (0xFFUL << MPU_MAIR1_Attr6_Pos) /*!< MPU MAIR1: Attr6 Mask */ + +#define MPU_MAIR1_Attr5_Pos 8U /*!< MPU MAIR1: Attr5 Position */ +#define MPU_MAIR1_Attr5_Msk (0xFFUL << MPU_MAIR1_Attr5_Pos) /*!< MPU MAIR1: Attr5 Mask */ + +#define MPU_MAIR1_Attr4_Pos 0U /*!< MPU MAIR1: Attr4 Position */ +#define MPU_MAIR1_Attr4_Msk (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/) /*!< MPU MAIR1: Attr4 Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SAU Security Attribution Unit (SAU) + \brief Type definitions for the Security Attribution Unit (SAU) + @{ + */ + +/** + \brief Structure type to access the Security Attribution Unit (SAU). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SAU Control Register */ + __IM uint32_t TYPE; /*!< Offset: 0x004 (R/ ) SAU Type Register */ +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) SAU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) SAU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) SAU Region Limit Address Register */ +#else + uint32_t RESERVED0[3]; +#endif + __IOM uint32_t SFSR; /*!< Offset: 0x014 (R/W) Secure Fault Status Register */ + __IOM uint32_t SFAR; /*!< Offset: 0x018 (R/W) Secure Fault Address Register */ +} SAU_Type; + +/* SAU Control Register Definitions */ +#define SAU_CTRL_ALLNS_Pos 1U /*!< SAU CTRL: ALLNS Position */ +#define SAU_CTRL_ALLNS_Msk (1UL << SAU_CTRL_ALLNS_Pos) /*!< SAU CTRL: ALLNS Mask */ + +#define SAU_CTRL_ENABLE_Pos 0U /*!< SAU CTRL: ENABLE Position */ +#define SAU_CTRL_ENABLE_Msk (1UL /*<< SAU_CTRL_ENABLE_Pos*/) /*!< SAU CTRL: ENABLE Mask */ + +/* SAU Type Register Definitions */ +#define SAU_TYPE_SREGION_Pos 0U /*!< SAU TYPE: SREGION Position */ +#define SAU_TYPE_SREGION_Msk (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/) /*!< SAU TYPE: SREGION Mask */ + +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) +/* SAU Region Number Register Definitions */ +#define SAU_RNR_REGION_Pos 0U /*!< SAU RNR: REGION Position */ +#define SAU_RNR_REGION_Msk (0xFFUL /*<< SAU_RNR_REGION_Pos*/) /*!< SAU RNR: REGION Mask */ + +/* SAU Region Base Address Register Definitions */ +#define SAU_RBAR_BADDR_Pos 5U /*!< SAU RBAR: BADDR Position */ +#define SAU_RBAR_BADDR_Msk (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos) /*!< SAU RBAR: BADDR Mask */ + +/* SAU Region Limit Address Register Definitions */ +#define SAU_RLAR_LADDR_Pos 5U /*!< SAU RLAR: LADDR Position */ +#define SAU_RLAR_LADDR_Msk (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos) /*!< SAU RLAR: LADDR Mask */ + +#define SAU_RLAR_NSC_Pos 1U /*!< SAU RLAR: NSC Position */ +#define SAU_RLAR_NSC_Msk (1UL << SAU_RLAR_NSC_Pos) /*!< SAU RLAR: NSC Mask */ + +#define SAU_RLAR_ENABLE_Pos 0U /*!< SAU RLAR: ENABLE Position */ +#define SAU_RLAR_ENABLE_Msk (1UL /*<< SAU_RLAR_ENABLE_Pos*/) /*!< SAU RLAR: ENABLE Mask */ + +#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */ + +/* Secure Fault Status Register Definitions */ +#define SAU_SFSR_LSERR_Pos 7U /*!< SAU SFSR: LSERR Position */ +#define SAU_SFSR_LSERR_Msk (1UL << SAU_SFSR_LSERR_Pos) /*!< SAU SFSR: LSERR Mask */ + +#define SAU_SFSR_SFARVALID_Pos 6U /*!< SAU SFSR: SFARVALID Position */ +#define SAU_SFSR_SFARVALID_Msk (1UL << SAU_SFSR_SFARVALID_Pos) /*!< SAU SFSR: SFARVALID Mask */ + +#define SAU_SFSR_LSPERR_Pos 5U /*!< SAU SFSR: LSPERR Position */ +#define SAU_SFSR_LSPERR_Msk (1UL << SAU_SFSR_LSPERR_Pos) /*!< SAU SFSR: LSPERR Mask */ + +#define SAU_SFSR_INVTRAN_Pos 4U /*!< SAU SFSR: INVTRAN Position */ +#define SAU_SFSR_INVTRAN_Msk (1UL << SAU_SFSR_INVTRAN_Pos) /*!< SAU SFSR: INVTRAN Mask */ + +#define SAU_SFSR_AUVIOL_Pos 3U /*!< SAU SFSR: AUVIOL Position */ +#define SAU_SFSR_AUVIOL_Msk (1UL << SAU_SFSR_AUVIOL_Pos) /*!< SAU SFSR: AUVIOL Mask */ + +#define SAU_SFSR_INVER_Pos 2U /*!< SAU SFSR: INVER Position */ +#define SAU_SFSR_INVER_Msk (1UL << SAU_SFSR_INVER_Pos) /*!< SAU SFSR: INVER Mask */ + +#define SAU_SFSR_INVIS_Pos 1U /*!< SAU SFSR: INVIS Position */ +#define SAU_SFSR_INVIS_Msk (1UL << SAU_SFSR_INVIS_Pos) /*!< SAU SFSR: INVIS Mask */ + +#define SAU_SFSR_INVEP_Pos 0U /*!< SAU SFSR: INVEP Position */ +#define SAU_SFSR_INVEP_Msk (1UL /*<< SAU_SFSR_INVEP_Pos*/) /*!< SAU SFSR: INVEP Mask */ + +/*@} end of group CMSIS_SAU */ +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_FPU Floating Point Unit (FPU) + \brief Type definitions for the Floating Point Unit (FPU) + @{ + */ + +/** + \brief Structure type to access the Floating Point Unit (FPU). + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IOM uint32_t FPCCR; /*!< Offset: 0x004 (R/W) Floating-Point Context Control Register */ + __IOM uint32_t FPCAR; /*!< Offset: 0x008 (R/W) Floating-Point Context Address Register */ + __IOM uint32_t FPDSCR; /*!< Offset: 0x00C (R/W) Floating-Point Default Status Control Register */ + __IM uint32_t MVFR0; /*!< Offset: 0x010 (R/ ) Media and FP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x014 (R/ ) Media and FP Feature Register 1 */ +} FPU_Type; + +/* Floating-Point Context Control Register Definitions */ +#define FPU_FPCCR_ASPEN_Pos 31U /*!< FPCCR: ASPEN bit Position */ +#define FPU_FPCCR_ASPEN_Msk (1UL << FPU_FPCCR_ASPEN_Pos) /*!< FPCCR: ASPEN bit Mask */ + +#define FPU_FPCCR_LSPEN_Pos 30U /*!< FPCCR: LSPEN Position */ +#define FPU_FPCCR_LSPEN_Msk (1UL << FPU_FPCCR_LSPEN_Pos) /*!< FPCCR: LSPEN bit Mask */ + +#define FPU_FPCCR_LSPENS_Pos 29U /*!< FPCCR: LSPENS Position */ +#define FPU_FPCCR_LSPENS_Msk (1UL << FPU_FPCCR_LSPENS_Pos) /*!< FPCCR: LSPENS bit Mask */ + +#define FPU_FPCCR_CLRONRET_Pos 28U /*!< FPCCR: CLRONRET Position */ +#define FPU_FPCCR_CLRONRET_Msk (1UL << FPU_FPCCR_CLRONRET_Pos) /*!< FPCCR: CLRONRET bit Mask */ + +#define FPU_FPCCR_CLRONRETS_Pos 27U /*!< FPCCR: CLRONRETS Position */ +#define FPU_FPCCR_CLRONRETS_Msk (1UL << FPU_FPCCR_CLRONRETS_Pos) /*!< FPCCR: CLRONRETS bit Mask */ + +#define FPU_FPCCR_TS_Pos 26U /*!< FPCCR: TS Position */ +#define FPU_FPCCR_TS_Msk (1UL << FPU_FPCCR_TS_Pos) /*!< FPCCR: TS bit Mask */ + +#define FPU_FPCCR_UFRDY_Pos 10U /*!< FPCCR: UFRDY Position */ +#define FPU_FPCCR_UFRDY_Msk (1UL << FPU_FPCCR_UFRDY_Pos) /*!< FPCCR: UFRDY bit Mask */ + +#define FPU_FPCCR_SPLIMVIOL_Pos 9U /*!< FPCCR: SPLIMVIOL Position */ +#define FPU_FPCCR_SPLIMVIOL_Msk (1UL << FPU_FPCCR_SPLIMVIOL_Pos) /*!< FPCCR: SPLIMVIOL bit Mask */ + +#define FPU_FPCCR_MONRDY_Pos 8U /*!< FPCCR: MONRDY Position */ +#define FPU_FPCCR_MONRDY_Msk (1UL << FPU_FPCCR_MONRDY_Pos) /*!< FPCCR: MONRDY bit Mask */ + +#define FPU_FPCCR_SFRDY_Pos 7U /*!< FPCCR: SFRDY Position */ +#define FPU_FPCCR_SFRDY_Msk (1UL << FPU_FPCCR_SFRDY_Pos) /*!< FPCCR: SFRDY bit Mask */ + +#define FPU_FPCCR_BFRDY_Pos 6U /*!< FPCCR: BFRDY Position */ +#define FPU_FPCCR_BFRDY_Msk (1UL << FPU_FPCCR_BFRDY_Pos) /*!< FPCCR: BFRDY bit Mask */ + +#define FPU_FPCCR_MMRDY_Pos 5U /*!< FPCCR: MMRDY Position */ +#define FPU_FPCCR_MMRDY_Msk (1UL << FPU_FPCCR_MMRDY_Pos) /*!< FPCCR: MMRDY bit Mask */ + +#define FPU_FPCCR_HFRDY_Pos 4U /*!< FPCCR: HFRDY Position */ +#define FPU_FPCCR_HFRDY_Msk (1UL << FPU_FPCCR_HFRDY_Pos) /*!< FPCCR: HFRDY bit Mask */ + +#define FPU_FPCCR_THREAD_Pos 3U /*!< FPCCR: processor mode bit Position */ +#define FPU_FPCCR_THREAD_Msk (1UL << FPU_FPCCR_THREAD_Pos) /*!< FPCCR: processor mode active bit Mask */ + +#define FPU_FPCCR_S_Pos 2U /*!< FPCCR: Security status of the FP context bit Position */ +#define FPU_FPCCR_S_Msk (1UL << FPU_FPCCR_S_Pos) /*!< FPCCR: Security status of the FP context bit Mask */ + +#define FPU_FPCCR_USER_Pos 1U /*!< FPCCR: privilege level bit Position */ +#define FPU_FPCCR_USER_Msk (1UL << FPU_FPCCR_USER_Pos) /*!< FPCCR: privilege level bit Mask */ + +#define FPU_FPCCR_LSPACT_Pos 0U /*!< FPCCR: Lazy state preservation active bit Position */ +#define FPU_FPCCR_LSPACT_Msk (1UL /*<< FPU_FPCCR_LSPACT_Pos*/) /*!< FPCCR: Lazy state preservation active bit Mask */ + +/* Floating-Point Context Address Register Definitions */ +#define FPU_FPCAR_ADDRESS_Pos 3U /*!< FPCAR: ADDRESS bit Position */ +#define FPU_FPCAR_ADDRESS_Msk (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos) /*!< FPCAR: ADDRESS bit Mask */ + +/* Floating-Point Default Status Control Register Definitions */ +#define FPU_FPDSCR_AHP_Pos 26U /*!< FPDSCR: AHP bit Position */ +#define FPU_FPDSCR_AHP_Msk (1UL << FPU_FPDSCR_AHP_Pos) /*!< FPDSCR: AHP bit Mask */ + +#define FPU_FPDSCR_DN_Pos 25U /*!< FPDSCR: DN bit Position */ +#define FPU_FPDSCR_DN_Msk (1UL << FPU_FPDSCR_DN_Pos) /*!< FPDSCR: DN bit Mask */ + +#define FPU_FPDSCR_FZ_Pos 24U /*!< FPDSCR: FZ bit Position */ +#define FPU_FPDSCR_FZ_Msk (1UL << FPU_FPDSCR_FZ_Pos) /*!< FPDSCR: FZ bit Mask */ + +#define FPU_FPDSCR_RMode_Pos 22U /*!< FPDSCR: RMode bit Position */ +#define FPU_FPDSCR_RMode_Msk (3UL << FPU_FPDSCR_RMode_Pos) /*!< FPDSCR: RMode bit Mask */ + +/* Media and FP Feature Register 0 Definitions */ +#define FPU_MVFR0_FP_rounding_modes_Pos 28U /*!< MVFR0: FP rounding modes bits Position */ +#define FPU_MVFR0_FP_rounding_modes_Msk (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos) /*!< MVFR0: FP rounding modes bits Mask */ + +#define FPU_MVFR0_Short_vectors_Pos 24U /*!< MVFR0: Short vectors bits Position */ +#define FPU_MVFR0_Short_vectors_Msk (0xFUL << FPU_MVFR0_Short_vectors_Pos) /*!< MVFR0: Short vectors bits Mask */ + +#define FPU_MVFR0_Square_root_Pos 20U /*!< MVFR0: Square root bits Position */ +#define FPU_MVFR0_Square_root_Msk (0xFUL << FPU_MVFR0_Square_root_Pos) /*!< MVFR0: Square root bits Mask */ + +#define FPU_MVFR0_Divide_Pos 16U /*!< MVFR0: Divide bits Position */ +#define FPU_MVFR0_Divide_Msk (0xFUL << FPU_MVFR0_Divide_Pos) /*!< MVFR0: Divide bits Mask */ + +#define FPU_MVFR0_FP_excep_trapping_Pos 12U /*!< MVFR0: FP exception trapping bits Position */ +#define FPU_MVFR0_FP_excep_trapping_Msk (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos) /*!< MVFR0: FP exception trapping bits Mask */ + +#define FPU_MVFR0_Double_precision_Pos 8U /*!< MVFR0: Double-precision bits Position */ +#define FPU_MVFR0_Double_precision_Msk (0xFUL << FPU_MVFR0_Double_precision_Pos) /*!< MVFR0: Double-precision bits Mask */ + +#define FPU_MVFR0_Single_precision_Pos 4U /*!< MVFR0: Single-precision bits Position */ +#define FPU_MVFR0_Single_precision_Msk (0xFUL << FPU_MVFR0_Single_precision_Pos) /*!< MVFR0: Single-precision bits Mask */ + +#define FPU_MVFR0_A_SIMD_registers_Pos 0U /*!< MVFR0: A_SIMD registers bits Position */ +#define FPU_MVFR0_A_SIMD_registers_Msk (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/) /*!< MVFR0: A_SIMD registers bits Mask */ + +/* Media and FP Feature Register 1 Definitions */ +#define FPU_MVFR1_FP_fused_MAC_Pos 28U /*!< MVFR1: FP fused MAC bits Position */ +#define FPU_MVFR1_FP_fused_MAC_Msk (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos) /*!< MVFR1: FP fused MAC bits Mask */ + +#define FPU_MVFR1_FP_HPFP_Pos 24U /*!< MVFR1: FP HPFP bits Position */ +#define FPU_MVFR1_FP_HPFP_Msk (0xFUL << FPU_MVFR1_FP_HPFP_Pos) /*!< MVFR1: FP HPFP bits Mask */ + +#define FPU_MVFR1_D_NaN_mode_Pos 4U /*!< MVFR1: D_NaN mode bits Position */ +#define FPU_MVFR1_D_NaN_mode_Msk (0xFUL << FPU_MVFR1_D_NaN_mode_Pos) /*!< MVFR1: D_NaN mode bits Mask */ + +#define FPU_MVFR1_FtZ_mode_Pos 0U /*!< MVFR1: FtZ mode bits Position */ +#define FPU_MVFR1_FtZ_mode_Msk (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/) /*!< MVFR1: FtZ mode bits Mask */ + +/*@} end of group CMSIS_FPU */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ + uint32_t RESERVED4[1U]; + __IOM uint32_t DAUTHCTRL; /*!< Offset: 0x014 (R/W) Debug Authentication Control Register */ + __IOM uint32_t DSCSR; /*!< Offset: 0x018 (R/W) Debug Security Control and Status Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESTART_ST_Pos 26U /*!< CoreDebug DHCSR: S_RESTART_ST Position */ +#define CoreDebug_DHCSR_S_RESTART_ST_Msk (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos) /*!< CoreDebug DHCSR: S_RESTART_ST Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/* Debug Authentication Control Register Definitions */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos 3U /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */ + +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos 2U /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos) /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */ + +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos 1U /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */ +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */ + +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos 0U /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */ + +/* Debug Security Control and Status Register Definitions */ +#define CoreDebug_DSCSR_CDS_Pos 16U /*!< CoreDebug DSCSR: CDS Position */ +#define CoreDebug_DSCSR_CDS_Msk (1UL << CoreDebug_DSCSR_CDS_Pos) /*!< CoreDebug DSCSR: CDS Mask */ + +#define CoreDebug_DSCSR_SBRSEL_Pos 1U /*!< CoreDebug DSCSR: SBRSEL Position */ +#define CoreDebug_DSCSR_SBRSEL_Msk (1UL << CoreDebug_DSCSR_SBRSEL_Pos) /*!< CoreDebug DSCSR: SBRSEL Mask */ + +#define CoreDebug_DSCSR_SBRSELEN_Pos 0U /*!< CoreDebug DSCSR: SBRSELEN Position */ +#define CoreDebug_DSCSR_SBRSELEN_Msk (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/) /*!< CoreDebug DSCSR: SBRSELEN Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ + #define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ + #define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ + #define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ + #define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ + #define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ + #define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ + #define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ + #define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + + #define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ + #define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ + #define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ + #define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + #define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ + #define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ + #define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ + #define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE ) /*!< Core Debug configuration struct */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ + #endif + + #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SAU_BASE (SCS_BASE + 0x0DD0UL) /*!< Security Attribution Unit */ + #define SAU ((SAU_Type *) SAU_BASE ) /*!< Security Attribution Unit */ + #endif + + #define FPU_BASE (SCS_BASE + 0x0F30UL) /*!< Floating Point Unit */ + #define FPU ((FPU_Type *) FPU_BASE ) /*!< Floating Point Unit */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SCS_BASE_NS (0xE002E000UL) /*!< System Control Space Base Address (non-secure address space) */ + #define CoreDebug_BASE_NS (0xE002EDF0UL) /*!< Core Debug Base Address (non-secure address space) */ + #define SysTick_BASE_NS (SCS_BASE_NS + 0x0010UL) /*!< SysTick Base Address (non-secure address space) */ + #define NVIC_BASE_NS (SCS_BASE_NS + 0x0100UL) /*!< NVIC Base Address (non-secure address space) */ + #define SCB_BASE_NS (SCS_BASE_NS + 0x0D00UL) /*!< System Control Block Base Address (non-secure address space) */ + + #define SCnSCB_NS ((SCnSCB_Type *) SCS_BASE_NS ) /*!< System control Register not in SCB(non-secure address space) */ + #define SCB_NS ((SCB_Type *) SCB_BASE_NS ) /*!< SCB configuration struct (non-secure address space) */ + #define SysTick_NS ((SysTick_Type *) SysTick_BASE_NS ) /*!< SysTick configuration struct (non-secure address space) */ + #define NVIC_NS ((NVIC_Type *) NVIC_BASE_NS ) /*!< NVIC configuration struct (non-secure address space) */ + #define CoreDebug_NS ((CoreDebug_Type *) CoreDebug_BASE_NS) /*!< Core Debug configuration struct (non-secure address space) */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE_NS (SCS_BASE_NS + 0x0D90UL) /*!< Memory Protection Unit (non-secure address space) */ + #define MPU_NS ((MPU_Type *) MPU_BASE_NS ) /*!< Memory Protection Unit (non-secure address space) */ + #endif + + #define FPU_BASE_NS (SCS_BASE_NS + 0x0F30UL) /*!< Floating Point Unit (non-secure address space) */ + #define FPU_NS ((FPU_Type *) FPU_BASE_NS ) /*!< Floating Point Unit (non-secure address space) */ + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* Special LR values for Secure/Non-Secure call handling and exception handling */ + +/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS */ +#define FNC_RETURN (0xFEFFFFFFUL) /* bit [0] ignored when processing a branch */ + +/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */ +#define EXC_RETURN_PREFIX (0xFF000000UL) /* bits [31:24] set to indicate an EXC_RETURN value */ +#define EXC_RETURN_S (0x00000040UL) /* bit [6] stack used to push registers: 0=Non-secure 1=Secure */ +#define EXC_RETURN_DCRS (0x00000020UL) /* bit [5] stacking rules for called registers: 0=skipped 1=saved */ +#define EXC_RETURN_FTYPE (0x00000010UL) /* bit [4] allocate stack for floating-point context: 0=done 1=skipped */ +#define EXC_RETURN_MODE (0x00000008UL) /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode */ +#define EXC_RETURN_SPSEL (0x00000004UL) /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP */ +#define EXC_RETURN_ES (0x00000001UL) /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */ + +/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking */ +#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) /* Value for processors with floating-point extension: */ +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125AUL) /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE */ +#else +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125BUL) /* Value for processors without floating-point extension */ +#endif + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Get Interrupt Target State + \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + \return 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Target State + \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |= ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Clear Interrupt Target State + \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + __DSB(); +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Set Priority Grouping (non-secure) + \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB_NS->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB_NS->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping (non-secure) + \details Reads the priority grouping field from the non-secure NVIC when in secure state. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void) +{ + return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt (non-secure) + \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Interrupt Enable status (non-secure) + \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt (non-secure) + \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Pending Interrupt (non-secure) + \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt (non-secure) + \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt (non-secure) + \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt (non-secure) + \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority (non-secure) + \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every non-secure processor exception. + */ +__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority (non-secure) + \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv8.h" + +#endif + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + uint32_t mvfr0; + + mvfr0 = FPU->MVFR0; + if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U) + { + return 2U; /* Double + Single precision FPU */ + } + else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U) + { + return 1U; /* Single precision FPU */ + } + else + { + return 0U; /* No FPU */ + } +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ########################## SAU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SAUFunctions SAU Functions + \brief Functions that configure the SAU. + @{ + */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + +/** + \brief Enable SAU + \details Enables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Enable(void) +{ + SAU->CTRL |= (SAU_CTRL_ENABLE_Msk); +} + + + +/** + \brief Disable SAU + \details Disables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Disable(void) +{ + SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk); +} + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_SAUFunctions */ + + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief System Tick Configuration (non-secure) + \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function TZ_SysTick_Config_NS is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick_NS->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick_NS->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick_NS->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_ARMV8MML_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0.h new file mode 100644 index 0000000000..cafae5a0a7 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0.h @@ -0,0 +1,952 @@ +/**************************************************************************//** + * @file core_cm0.h + * @brief CMSIS Cortex-M0 Core Peripheral Access Layer Header File + * @version V5.0.6 + * @date 13. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM0_H_GENERIC +#define __CORE_CM0_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M0 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM0 definitions */ +#define __CM0_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM0_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM0_CMSIS_VERSION ((__CM0_CMSIS_VERSION_MAIN << 16U) | \ + __CM0_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (0U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM0_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM0_H_DEPENDANT +#define __CORE_CM0_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM0_REV + #define __CM0_REV 0x0000U + #warning "__CM0_REV not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M0 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:28; /*!< bit: 0..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t _reserved1:3; /*!< bit: 25..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t _reserved0:1; /*!< bit: 0 Reserved */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[1U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[31U]; + __IOM uint32_t ICER[1U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RESERVED1[31U]; + __IOM uint32_t ISPR[1U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[31U]; + __IOM uint32_t ICPR[1U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[31U]; + uint32_t RESERVED4[64U]; + __IOM uint32_t IP[8U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + uint32_t RESERVED0; + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED1; + __IOM uint32_t SHP[2U]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Cortex-M0 Core Debug Registers (DCB registers, SHCSR, and DFSR) are only accessible over DAP and not via processor. + Therefore they are not covered by the Cortex-M0 header file. + @{ + */ +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ +/*#define NVIC_GetActive __NVIC_GetActive not available for Cortex-M0 */ + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ + + +/* Interrupt Priorities are WORD accessible only under Armv6-M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( ((((uint32_t)(int32_t)(IRQn)) ) & 0x03UL) * 8UL) +#define _SHP_IDX(IRQn) ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >> 2UL) ) +#define _IP_IDX(IRQn) ( (((uint32_t)(int32_t)(IRQn)) >> 2UL) ) + +#define __NVIC_SetPriorityGrouping(X) (void)(X) +#define __NVIC_GetPriorityGrouping() (0U) + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[_IP_IDX(IRQn)] = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + Address 0 must be mapped to SRAM. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t vectors = 0x0U; + (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector; + /* ARM Application Note 321 states that the M0 does not require the architectural barrier */ +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t vectors = 0x0U; + return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)); +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM0_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0plus.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0plus.h new file mode 100644 index 0000000000..d104965db5 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm0plus.h @@ -0,0 +1,1085 @@ +/**************************************************************************//** + * @file core_cm0plus.h + * @brief CMSIS Cortex-M0+ Core Peripheral Access Layer Header File + * @version V5.0.7 + * @date 13. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM0PLUS_H_GENERIC +#define __CORE_CM0PLUS_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex-M0+ + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM0+ definitions */ +#define __CM0PLUS_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM0PLUS_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM0PLUS_CMSIS_VERSION ((__CM0PLUS_CMSIS_VERSION_MAIN << 16U) | \ + __CM0PLUS_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (0U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM0PLUS_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM0PLUS_H_DEPENDANT +#define __CORE_CM0PLUS_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM0PLUS_REV + #define __CM0PLUS_REV 0x0000U + #warning "__CM0PLUS_REV not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __VTOR_PRESENT + #define __VTOR_PRESENT 0U + #warning "__VTOR_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex-M0+ */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core MPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:28; /*!< bit: 0..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t _reserved1:3; /*!< bit: 25..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[1U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[31U]; + __IOM uint32_t ICER[1U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RESERVED1[31U]; + __IOM uint32_t ISPR[1U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[31U]; + __IOM uint32_t ICPR[1U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[31U]; + uint32_t RESERVED4[64U]; + __IOM uint32_t IP[8U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ +#else + uint32_t RESERVED0; +#endif + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED1; + __IOM uint32_t SHP[2U]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) +/* SCB Interrupt Control State Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 8U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0xFFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ +#endif + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region RNRber Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RASR; /*!< Offset: 0x010 (R/W) MPU Region Attribute and Size Register */ +} MPU_Type; + +#define MPU_TYPE_RALIASES 1U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_ADDR_Pos 8U /*!< MPU RBAR: ADDR Position */ +#define MPU_RBAR_ADDR_Msk (0xFFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */ + +#define MPU_RBAR_VALID_Pos 4U /*!< MPU RBAR: VALID Position */ +#define MPU_RBAR_VALID_Msk (1UL << MPU_RBAR_VALID_Pos) /*!< MPU RBAR: VALID Mask */ + +#define MPU_RBAR_REGION_Pos 0U /*!< MPU RBAR: REGION Position */ +#define MPU_RBAR_REGION_Msk (0xFUL /*<< MPU_RBAR_REGION_Pos*/) /*!< MPU RBAR: REGION Mask */ + +/* MPU Region Attribute and Size Register Definitions */ +#define MPU_RASR_ATTRS_Pos 16U /*!< MPU RASR: MPU Region Attribute field Position */ +#define MPU_RASR_ATTRS_Msk (0xFFFFUL << MPU_RASR_ATTRS_Pos) /*!< MPU RASR: MPU Region Attribute field Mask */ + +#define MPU_RASR_XN_Pos 28U /*!< MPU RASR: ATTRS.XN Position */ +#define MPU_RASR_XN_Msk (1UL << MPU_RASR_XN_Pos) /*!< MPU RASR: ATTRS.XN Mask */ + +#define MPU_RASR_AP_Pos 24U /*!< MPU RASR: ATTRS.AP Position */ +#define MPU_RASR_AP_Msk (0x7UL << MPU_RASR_AP_Pos) /*!< MPU RASR: ATTRS.AP Mask */ + +#define MPU_RASR_TEX_Pos 19U /*!< MPU RASR: ATTRS.TEX Position */ +#define MPU_RASR_TEX_Msk (0x7UL << MPU_RASR_TEX_Pos) /*!< MPU RASR: ATTRS.TEX Mask */ + +#define MPU_RASR_S_Pos 18U /*!< MPU RASR: ATTRS.S Position */ +#define MPU_RASR_S_Msk (1UL << MPU_RASR_S_Pos) /*!< MPU RASR: ATTRS.S Mask */ + +#define MPU_RASR_C_Pos 17U /*!< MPU RASR: ATTRS.C Position */ +#define MPU_RASR_C_Msk (1UL << MPU_RASR_C_Pos) /*!< MPU RASR: ATTRS.C Mask */ + +#define MPU_RASR_B_Pos 16U /*!< MPU RASR: ATTRS.B Position */ +#define MPU_RASR_B_Msk (1UL << MPU_RASR_B_Pos) /*!< MPU RASR: ATTRS.B Mask */ + +#define MPU_RASR_SRD_Pos 8U /*!< MPU RASR: Sub-Region Disable Position */ +#define MPU_RASR_SRD_Msk (0xFFUL << MPU_RASR_SRD_Pos) /*!< MPU RASR: Sub-Region Disable Mask */ + +#define MPU_RASR_SIZE_Pos 1U /*!< MPU RASR: Region Size Field Position */ +#define MPU_RASR_SIZE_Msk (0x1FUL << MPU_RASR_SIZE_Pos) /*!< MPU RASR: Region Size Field Mask */ + +#define MPU_RASR_ENABLE_Pos 0U /*!< MPU RASR: Region enable bit Position */ +#define MPU_RASR_ENABLE_Msk (1UL /*<< MPU_RASR_ENABLE_Pos*/) /*!< MPU RASR: Region enable bit Disable Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Cortex-M0+ Core Debug Registers (DCB registers, SHCSR, and DFSR) are only accessible over DAP and not via processor. + Therefore they are not covered by the Cortex-M0+ header file. + @{ + */ +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ +#endif + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ +/*#define NVIC_GetActive __NVIC_GetActive not available for Cortex-M0+ */ + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ + + +/* Interrupt Priorities are WORD accessible only under Armv6-M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( ((((uint32_t)(int32_t)(IRQn)) ) & 0x03UL) * 8UL) +#define _SHP_IDX(IRQn) ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >> 2UL) ) +#define _IP_IDX(IRQn) ( (((uint32_t)(int32_t)(IRQn)) >> 2UL) ) + +#define __NVIC_SetPriorityGrouping(X) (void)(X) +#define __NVIC_GetPriorityGrouping() (0U) + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[_IP_IDX(IRQn)] = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + If VTOR is not present address 0 must be mapped to SRAM. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + uint32_t vectors = SCB->VTOR; +#else + uint32_t vectors = 0x0U; +#endif + (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector; + /* ARM Application Note 321 states that the M0+ does not require the architectural barrier */ +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + uint32_t vectors = SCB->VTOR; +#else + uint32_t vectors = 0x0U; +#endif + return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)); +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv7.h" + +#endif + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM0PLUS_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm1.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm1.h new file mode 100644 index 0000000000..76b4569743 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm1.h @@ -0,0 +1,979 @@ +/**************************************************************************//** + * @file core_cm1.h + * @brief CMSIS Cortex-M1 Core Peripheral Access Layer Header File + * @version V1.0.1 + * @date 12. November 2018 + ******************************************************************************/ +/* + * Copyright (c) 2009-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM1_H_GENERIC +#define __CORE_CM1_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M1 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM1 definitions */ +#define __CM1_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM1_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM1_CMSIS_VERSION ((__CM1_CMSIS_VERSION_MAIN << 16U) | \ + __CM1_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (1U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM1_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM1_H_DEPENDANT +#define __CORE_CM1_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM1_REV + #define __CM1_REV 0x0100U + #warning "__CM1_REV not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M1 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:28; /*!< bit: 0..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t _reserved1:3; /*!< bit: 25..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t _reserved0:1; /*!< bit: 0 Reserved */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[1U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[31U]; + __IOM uint32_t ICER[1U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[31U]; + __IOM uint32_t ISPR[1U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[31U]; + __IOM uint32_t ICPR[1U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[31U]; + uint32_t RESERVED4[64U]; + __IOM uint32_t IP[8U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + uint32_t RESERVED0; + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED1; + __IOM uint32_t SHP[2U]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ +} SCnSCB_Type; + +/* Auxiliary Control Register Definitions */ +#define SCnSCB_ACTLR_ITCMUAEN_Pos 4U /*!< ACTLR: Instruction TCM Upper Alias Enable Position */ +#define SCnSCB_ACTLR_ITCMUAEN_Msk (1UL << SCnSCB_ACTLR_ITCMUAEN_Pos) /*!< ACTLR: Instruction TCM Upper Alias Enable Mask */ + +#define SCnSCB_ACTLR_ITCMLAEN_Pos 3U /*!< ACTLR: Instruction TCM Lower Alias Enable Position */ +#define SCnSCB_ACTLR_ITCMLAEN_Msk (1UL << SCnSCB_ACTLR_ITCMLAEN_Pos) /*!< ACTLR: Instruction TCM Lower Alias Enable Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Cortex-M1 Core Debug Registers (DCB registers, SHCSR, and DFSR) are only accessible over DAP and not via processor. + Therefore they are not covered by the Cortex-M1 header file. + @{ + */ +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ +/*#define NVIC_GetActive __NVIC_GetActive not available for Cortex-M1 */ + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ + + +/* Interrupt Priorities are WORD accessible only under Armv6-M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( ((((uint32_t)(int32_t)(IRQn)) ) & 0x03UL) * 8UL) +#define _SHP_IDX(IRQn) ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >> 2UL) ) +#define _IP_IDX(IRQn) ( (((uint32_t)(int32_t)(IRQn)) >> 2UL) ) + +#define __NVIC_SetPriorityGrouping(X) (void)(X) +#define __NVIC_GetPriorityGrouping() (0U) + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[_IP_IDX(IRQn)] = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + Address 0 must be mapped to SRAM. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t *vectors = (uint32_t *)0x0U; + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + /* ARM Application Note 321 states that the M1 does not require the architectural barrier */ +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t *vectors = (uint32_t *)0x0U; + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM1_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm23.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm23.h new file mode 100644 index 0000000000..b79c6af0b1 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm23.h @@ -0,0 +1,1996 @@ +/**************************************************************************//** + * @file core_cm23.h + * @brief CMSIS Cortex-M23 Core Peripheral Access Layer Header File + * @version V5.0.8 + * @date 12. November 2018 + ******************************************************************************/ +/* + * Copyright (c) 2009-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM23_H_GENERIC +#define __CORE_CM23_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M23 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS definitions */ +#define __CM23_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM23_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM23_CMSIS_VERSION ((__CM23_CMSIS_VERSION_MAIN << 16U) | \ + __CM23_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (23U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM23_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM23_H_DEPENDANT +#define __CORE_CM23_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM23_REV + #define __CM23_REV 0x0000U + #warning "__CM23_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __SAUREGION_PRESENT + #define __SAUREGION_PRESENT 0U + #warning "__SAUREGION_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __VTOR_PRESENT + #define __VTOR_PRESENT 0U + #warning "__VTOR_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif + + #ifndef __ETM_PRESENT + #define __ETM_PRESENT 0U + #warning "__ETM_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MTB_PRESENT + #define __MTB_PRESENT 0U + #warning "__MTB_PRESENT not defined in device header file; using default!" + #endif + +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M23 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core SAU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:28; /*!< bit: 0..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t _reserved1:3; /*!< bit: 25..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack-pointer select */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[16U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[16U]; + __IOM uint32_t ICER[16U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[16U]; + __IOM uint32_t ISPR[16U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[16U]; + __IOM uint32_t ICPR[16U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[16U]; + __IOM uint32_t IABR[16U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[16U]; + __IOM uint32_t ITNS[16U]; /*!< Offset: 0x280 (R/W) Interrupt Non-Secure State Register */ + uint32_t RESERVED5[16U]; + __IOM uint32_t IPR[124U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ +#else + uint32_t RESERVED0; +#endif + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED1; + __IOM uint32_t SHPR[2U]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_PENDNMISET_Pos 31U /*!< SCB ICSR: PENDNMISET Position */ +#define SCB_ICSR_PENDNMISET_Msk (1UL << SCB_ICSR_PENDNMISET_Pos) /*!< SCB ICSR: PENDNMISET Mask */ + +#define SCB_ICSR_NMIPENDSET_Pos SCB_ICSR_PENDNMISET_Pos /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */ +#define SCB_ICSR_NMIPENDSET_Msk SCB_ICSR_PENDNMISET_Msk /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */ + +#define SCB_ICSR_PENDNMICLR_Pos 30U /*!< SCB ICSR: PENDNMICLR Position */ +#define SCB_ICSR_PENDNMICLR_Msk (1UL << SCB_ICSR_PENDNMICLR_Pos) /*!< SCB ICSR: PENDNMICLR Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_STTNS_Pos 24U /*!< SCB ICSR: STTNS Position (Security Extension) */ +#define SCB_ICSR_STTNS_Msk (1UL << SCB_ICSR_STTNS_Pos) /*!< SCB ICSR: STTNS Mask (Security Extension) */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ +#endif + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIS_Pos 14U /*!< SCB AIRCR: PRIS Position */ +#define SCB_AIRCR_PRIS_Msk (1UL << SCB_AIRCR_PRIS_Pos) /*!< SCB AIRCR: PRIS Mask */ + +#define SCB_AIRCR_BFHFNMINS_Pos 13U /*!< SCB AIRCR: BFHFNMINS Position */ +#define SCB_AIRCR_BFHFNMINS_Msk (1UL << SCB_AIRCR_BFHFNMINS_Pos) /*!< SCB AIRCR: BFHFNMINS Mask */ + +#define SCB_AIRCR_SYSRESETREQS_Pos 3U /*!< SCB AIRCR: SYSRESETREQS Position */ +#define SCB_AIRCR_SYSRESETREQS_Msk (1UL << SCB_AIRCR_SYSRESETREQS_Pos) /*!< SCB AIRCR: SYSRESETREQS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEPS_Pos 3U /*!< SCB SCR: SLEEPDEEPS Position */ +#define SCB_SCR_SLEEPDEEPS_Msk (1UL << SCB_SCR_SLEEPDEEPS_Pos) /*!< SCB SCR: SLEEPDEEPS Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_BP_Pos 18U /*!< SCB CCR: BP Position */ +#define SCB_CCR_BP_Msk (1UL << SCB_CCR_BP_Pos) /*!< SCB CCR: BP Mask */ + +#define SCB_CCR_IC_Pos 17U /*!< SCB CCR: IC Position */ +#define SCB_CCR_IC_Msk (1UL << SCB_CCR_IC_Pos) /*!< SCB CCR: IC Mask */ + +#define SCB_CCR_DC_Pos 16U /*!< SCB CCR: DC Position */ +#define SCB_CCR_DC_Msk (1UL << SCB_CCR_DC_Pos) /*!< SCB CCR: DC Mask */ + +#define SCB_CCR_STKOFHFNMIGN_Pos 10U /*!< SCB CCR: STKOFHFNMIGN Position */ +#define SCB_CCR_STKOFHFNMIGN_Msk (1UL << SCB_CCR_STKOFHFNMIGN_Pos) /*!< SCB CCR: STKOFHFNMIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_HARDFAULTPENDED_Pos 21U /*!< SCB SHCSR: HARDFAULTPENDED Position */ +#define SCB_SHCSR_HARDFAULTPENDED_Msk (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos) /*!< SCB SHCSR: HARDFAULTPENDED Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_NMIACT_Pos 5U /*!< SCB SHCSR: NMIACT Position */ +#define SCB_SHCSR_NMIACT_Msk (1UL << SCB_SHCSR_NMIACT_Pos) /*!< SCB SHCSR: NMIACT Mask */ + +#define SCB_SHCSR_HARDFAULTACT_Pos 2U /*!< SCB SHCSR: HARDFAULTACT Position */ +#define SCB_SHCSR_HARDFAULTACT_Msk (1UL << SCB_SHCSR_HARDFAULTACT_Pos) /*!< SCB SHCSR: HARDFAULTACT Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + uint32_t RESERVED0[6U]; + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + uint32_t RESERVED3[1U]; + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED4[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + uint32_t RESERVED5[1U]; + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED6[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + uint32_t RESERVED7[1U]; + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ + uint32_t RESERVED8[1U]; + __IOM uint32_t COMP4; /*!< Offset: 0x060 (R/W) Comparator Register 4 */ + uint32_t RESERVED9[1U]; + __IOM uint32_t FUNCTION4; /*!< Offset: 0x068 (R/W) Function Register 4 */ + uint32_t RESERVED10[1U]; + __IOM uint32_t COMP5; /*!< Offset: 0x070 (R/W) Comparator Register 5 */ + uint32_t RESERVED11[1U]; + __IOM uint32_t FUNCTION5; /*!< Offset: 0x078 (R/W) Function Register 5 */ + uint32_t RESERVED12[1U]; + __IOM uint32_t COMP6; /*!< Offset: 0x080 (R/W) Comparator Register 6 */ + uint32_t RESERVED13[1U]; + __IOM uint32_t FUNCTION6; /*!< Offset: 0x088 (R/W) Function Register 6 */ + uint32_t RESERVED14[1U]; + __IOM uint32_t COMP7; /*!< Offset: 0x090 (R/W) Comparator Register 7 */ + uint32_t RESERVED15[1U]; + __IOM uint32_t FUNCTION7; /*!< Offset: 0x098 (R/W) Function Register 7 */ + uint32_t RESERVED16[1U]; + __IOM uint32_t COMP8; /*!< Offset: 0x0A0 (R/W) Comparator Register 8 */ + uint32_t RESERVED17[1U]; + __IOM uint32_t FUNCTION8; /*!< Offset: 0x0A8 (R/W) Function Register 8 */ + uint32_t RESERVED18[1U]; + __IOM uint32_t COMP9; /*!< Offset: 0x0B0 (R/W) Comparator Register 9 */ + uint32_t RESERVED19[1U]; + __IOM uint32_t FUNCTION9; /*!< Offset: 0x0B8 (R/W) Function Register 9 */ + uint32_t RESERVED20[1U]; + __IOM uint32_t COMP10; /*!< Offset: 0x0C0 (R/W) Comparator Register 10 */ + uint32_t RESERVED21[1U]; + __IOM uint32_t FUNCTION10; /*!< Offset: 0x0C8 (R/W) Function Register 10 */ + uint32_t RESERVED22[1U]; + __IOM uint32_t COMP11; /*!< Offset: 0x0D0 (R/W) Comparator Register 11 */ + uint32_t RESERVED23[1U]; + __IOM uint32_t FUNCTION11; /*!< Offset: 0x0D8 (R/W) Function Register 11 */ + uint32_t RESERVED24[1U]; + __IOM uint32_t COMP12; /*!< Offset: 0x0E0 (R/W) Comparator Register 12 */ + uint32_t RESERVED25[1U]; + __IOM uint32_t FUNCTION12; /*!< Offset: 0x0E8 (R/W) Function Register 12 */ + uint32_t RESERVED26[1U]; + __IOM uint32_t COMP13; /*!< Offset: 0x0F0 (R/W) Comparator Register 13 */ + uint32_t RESERVED27[1U]; + __IOM uint32_t FUNCTION13; /*!< Offset: 0x0F8 (R/W) Function Register 13 */ + uint32_t RESERVED28[1U]; + __IOM uint32_t COMP14; /*!< Offset: 0x100 (R/W) Comparator Register 14 */ + uint32_t RESERVED29[1U]; + __IOM uint32_t FUNCTION14; /*!< Offset: 0x108 (R/W) Function Register 14 */ + uint32_t RESERVED30[1U]; + __IOM uint32_t COMP15; /*!< Offset: 0x110 (R/W) Comparator Register 15 */ + uint32_t RESERVED31[1U]; + __IOM uint32_t FUNCTION15; /*!< Offset: 0x118 (R/W) Function Register 15 */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_ID_Pos 27U /*!< DWT FUNCTION: ID Position */ +#define DWT_FUNCTION_ID_Msk (0x1FUL << DWT_FUNCTION_ID_Pos) /*!< DWT FUNCTION: ID Mask */ + +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_ACTION_Pos 4U /*!< DWT FUNCTION: ACTION Position */ +#define DWT_FUNCTION_ACTION_Msk (0x3UL << DWT_FUNCTION_ACTION_Pos) /*!< DWT FUNCTION: ACTION Mask */ + +#define DWT_FUNCTION_MATCH_Pos 0U /*!< DWT FUNCTION: MATCH Position */ +#define DWT_FUNCTION_MATCH_Msk (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/) /*!< DWT FUNCTION: MATCH Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IOM uint32_t PSCR; /*!< Offset: 0x308 (R/W) Periodic Synchronization Control Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER Register */ + __IM uint32_t ITFTTD0; /*!< Offset: 0xEEC (R/ ) Integration Test FIFO Test Data 0 Register */ + __IOM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/W) Integration Test ATB Control Register 2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) Integration Test ATB Control Register 0 */ + __IM uint32_t ITFTTD1; /*!< Offset: 0xEFC (R/ ) Integration Test FIFO Test Data 1 Register */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) Device Configuration Register */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) Device Type Identifier Register */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_FOnMan_Pos 6U /*!< TPI FFCR: FOnMan Position */ +#define TPI_FFCR_FOnMan_Msk (0x1UL << TPI_FFCR_FOnMan_Pos) /*!< TPI FFCR: FOnMan Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration Test FIFO Test Data 0 Register Definitions */ +#define TPI_ITFTTD0_ATB_IF2_ATVALID_Pos 29U /*!< TPI ITFTTD0: ATB Interface 2 ATVALIDPosition */ +#define TPI_ITFTTD0_ATB_IF2_ATVALID_Msk (0x3UL << TPI_ITFTTD0_ATB_IF2_ATVALID_Pos) /*!< TPI ITFTTD0: ATB Interface 2 ATVALID Mask */ + +#define TPI_ITFTTD0_ATB_IF2_bytecount_Pos 27U /*!< TPI ITFTTD0: ATB Interface 2 byte count Position */ +#define TPI_ITFTTD0_ATB_IF2_bytecount_Msk (0x3UL << TPI_ITFTTD0_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 2 byte count Mask */ + +#define TPI_ITFTTD0_ATB_IF1_ATVALID_Pos 26U /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Position */ +#define TPI_ITFTTD0_ATB_IF1_ATVALID_Msk (0x3UL << TPI_ITFTTD0_ATB_IF1_ATVALID_Pos) /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Mask */ + +#define TPI_ITFTTD0_ATB_IF1_bytecount_Pos 24U /*!< TPI ITFTTD0: ATB Interface 1 byte count Position */ +#define TPI_ITFTTD0_ATB_IF1_bytecount_Msk (0x3UL << TPI_ITFTTD0_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 1 byte countt Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data2_Pos 16U /*!< TPI ITFTTD0: ATB Interface 1 data2 Position */ +#define TPI_ITFTTD0_ATB_IF1_data2_Msk (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos) /*!< TPI ITFTTD0: ATB Interface 1 data2 Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data1_Pos 8U /*!< TPI ITFTTD0: ATB Interface 1 data1 Position */ +#define TPI_ITFTTD0_ATB_IF1_data1_Msk (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos) /*!< TPI ITFTTD0: ATB Interface 1 data1 Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data0_Pos 0U /*!< TPI ITFTTD0: ATB Interface 1 data0 Position */ +#define TPI_ITFTTD0_ATB_IF1_data0_Msk (0xFFUL /*<< TPI_ITFTTD0_ATB_IF1_data0_Pos*/) /*!< TPI ITFTTD0: ATB Interface 1 data0 Mask */ + +/* TPI Integration Test ATB Control Register 2 Register Definitions */ +#define TPI_ITATBCTR2_AFVALID2S_Pos 1U /*!< TPI ITATBCTR2: AFVALID2S Position */ +#define TPI_ITATBCTR2_AFVALID2S_Msk (0x1UL << TPI_ITATBCTR2_AFVALID2S_Pos) /*!< TPI ITATBCTR2: AFVALID2SS Mask */ + +#define TPI_ITATBCTR2_AFVALID1S_Pos 1U /*!< TPI ITATBCTR2: AFVALID1S Position */ +#define TPI_ITATBCTR2_AFVALID1S_Msk (0x1UL << TPI_ITATBCTR2_AFVALID1S_Pos) /*!< TPI ITATBCTR2: AFVALID1SS Mask */ + +#define TPI_ITATBCTR2_ATREADY2S_Pos 0U /*!< TPI ITATBCTR2: ATREADY2S Position */ +#define TPI_ITATBCTR2_ATREADY2S_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY2S_Pos*/) /*!< TPI ITATBCTR2: ATREADY2S Mask */ + +#define TPI_ITATBCTR2_ATREADY1S_Pos 0U /*!< TPI ITATBCTR2: ATREADY1S Position */ +#define TPI_ITATBCTR2_ATREADY1S_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY1S_Pos*/) /*!< TPI ITATBCTR2: ATREADY1S Mask */ + +/* TPI Integration Test FIFO Test Data 1 Register Definitions */ +#define TPI_ITFTTD1_ATB_IF2_ATVALID_Pos 29U /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Position */ +#define TPI_ITFTTD1_ATB_IF2_ATVALID_Msk (0x3UL << TPI_ITFTTD1_ATB_IF2_ATVALID_Pos) /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Mask */ + +#define TPI_ITFTTD1_ATB_IF2_bytecount_Pos 27U /*!< TPI ITFTTD1: ATB Interface 2 byte count Position */ +#define TPI_ITFTTD1_ATB_IF2_bytecount_Msk (0x3UL << TPI_ITFTTD1_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 2 byte count Mask */ + +#define TPI_ITFTTD1_ATB_IF1_ATVALID_Pos 26U /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Position */ +#define TPI_ITFTTD1_ATB_IF1_ATVALID_Msk (0x3UL << TPI_ITFTTD1_ATB_IF1_ATVALID_Pos) /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Mask */ + +#define TPI_ITFTTD1_ATB_IF1_bytecount_Pos 24U /*!< TPI ITFTTD1: ATB Interface 1 byte count Position */ +#define TPI_ITFTTD1_ATB_IF1_bytecount_Msk (0x3UL << TPI_ITFTTD1_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 1 byte countt Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data2_Pos 16U /*!< TPI ITFTTD1: ATB Interface 2 data2 Position */ +#define TPI_ITFTTD1_ATB_IF2_data2_Msk (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos) /*!< TPI ITFTTD1: ATB Interface 2 data2 Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data1_Pos 8U /*!< TPI ITFTTD1: ATB Interface 2 data1 Position */ +#define TPI_ITFTTD1_ATB_IF2_data1_Msk (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos) /*!< TPI ITFTTD1: ATB Interface 2 data1 Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data0_Pos 0U /*!< TPI ITFTTD1: ATB Interface 2 data0 Position */ +#define TPI_ITFTTD1_ATB_IF2_data0_Msk (0xFFUL /*<< TPI_ITFTTD1_ATB_IF2_data0_Pos*/) /*!< TPI ITFTTD1: ATB Interface 2 data0 Mask */ + +/* TPI Integration Test ATB Control Register 0 Definitions */ +#define TPI_ITATBCTR0_AFVALID2S_Pos 1U /*!< TPI ITATBCTR0: AFVALID2S Position */ +#define TPI_ITATBCTR0_AFVALID2S_Msk (0x1UL << TPI_ITATBCTR0_AFVALID2S_Pos) /*!< TPI ITATBCTR0: AFVALID2SS Mask */ + +#define TPI_ITATBCTR0_AFVALID1S_Pos 1U /*!< TPI ITATBCTR0: AFVALID1S Position */ +#define TPI_ITATBCTR0_AFVALID1S_Msk (0x1UL << TPI_ITATBCTR0_AFVALID1S_Pos) /*!< TPI ITATBCTR0: AFVALID1SS Mask */ + +#define TPI_ITATBCTR0_ATREADY2S_Pos 0U /*!< TPI ITATBCTR0: ATREADY2S Position */ +#define TPI_ITATBCTR0_ATREADY2S_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY2S_Pos*/) /*!< TPI ITATBCTR0: ATREADY2S Mask */ + +#define TPI_ITATBCTR0_ATREADY1S_Pos 0U /*!< TPI ITATBCTR0: ATREADY1S Position */ +#define TPI_ITATBCTR0_ATREADY1S_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY1S_Pos*/) /*!< TPI ITATBCTR0: ATREADY1S Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_FIFOSZ_Pos 6U /*!< TPI DEVID: FIFOSZ Position */ +#define TPI_DEVID_FIFOSZ_Msk (0x7UL << TPI_DEVID_FIFOSZ_Pos) /*!< TPI DEVID: FIFOSZ Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x3FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) MPU Region Limit Address Register */ + uint32_t RESERVED0[7U]; + union { + __IOM uint32_t MAIR[2]; + struct { + __IOM uint32_t MAIR0; /*!< Offset: 0x030 (R/W) MPU Memory Attribute Indirection Register 0 */ + __IOM uint32_t MAIR1; /*!< Offset: 0x034 (R/W) MPU Memory Attribute Indirection Register 1 */ + }; + }; +} MPU_Type; + +#define MPU_TYPE_RALIASES 1U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_BASE_Pos 5U /*!< MPU RBAR: BASE Position */ +#define MPU_RBAR_BASE_Msk (0x7FFFFFFUL << MPU_RBAR_BASE_Pos) /*!< MPU RBAR: BASE Mask */ + +#define MPU_RBAR_SH_Pos 3U /*!< MPU RBAR: SH Position */ +#define MPU_RBAR_SH_Msk (0x3UL << MPU_RBAR_SH_Pos) /*!< MPU RBAR: SH Mask */ + +#define MPU_RBAR_AP_Pos 1U /*!< MPU RBAR: AP Position */ +#define MPU_RBAR_AP_Msk (0x3UL << MPU_RBAR_AP_Pos) /*!< MPU RBAR: AP Mask */ + +#define MPU_RBAR_XN_Pos 0U /*!< MPU RBAR: XN Position */ +#define MPU_RBAR_XN_Msk (01UL /*<< MPU_RBAR_XN_Pos*/) /*!< MPU RBAR: XN Mask */ + +/* MPU Region Limit Address Register Definitions */ +#define MPU_RLAR_LIMIT_Pos 5U /*!< MPU RLAR: LIMIT Position */ +#define MPU_RLAR_LIMIT_Msk (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos) /*!< MPU RLAR: LIMIT Mask */ + +#define MPU_RLAR_AttrIndx_Pos 1U /*!< MPU RLAR: AttrIndx Position */ +#define MPU_RLAR_AttrIndx_Msk (0x7UL << MPU_RLAR_AttrIndx_Pos) /*!< MPU RLAR: AttrIndx Mask */ + +#define MPU_RLAR_EN_Pos 0U /*!< MPU RLAR: EN Position */ +#define MPU_RLAR_EN_Msk (1UL /*<< MPU_RLAR_EN_Pos*/) /*!< MPU RLAR: EN Mask */ + +/* MPU Memory Attribute Indirection Register 0 Definitions */ +#define MPU_MAIR0_Attr3_Pos 24U /*!< MPU MAIR0: Attr3 Position */ +#define MPU_MAIR0_Attr3_Msk (0xFFUL << MPU_MAIR0_Attr3_Pos) /*!< MPU MAIR0: Attr3 Mask */ + +#define MPU_MAIR0_Attr2_Pos 16U /*!< MPU MAIR0: Attr2 Position */ +#define MPU_MAIR0_Attr2_Msk (0xFFUL << MPU_MAIR0_Attr2_Pos) /*!< MPU MAIR0: Attr2 Mask */ + +#define MPU_MAIR0_Attr1_Pos 8U /*!< MPU MAIR0: Attr1 Position */ +#define MPU_MAIR0_Attr1_Msk (0xFFUL << MPU_MAIR0_Attr1_Pos) /*!< MPU MAIR0: Attr1 Mask */ + +#define MPU_MAIR0_Attr0_Pos 0U /*!< MPU MAIR0: Attr0 Position */ +#define MPU_MAIR0_Attr0_Msk (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/) /*!< MPU MAIR0: Attr0 Mask */ + +/* MPU Memory Attribute Indirection Register 1 Definitions */ +#define MPU_MAIR1_Attr7_Pos 24U /*!< MPU MAIR1: Attr7 Position */ +#define MPU_MAIR1_Attr7_Msk (0xFFUL << MPU_MAIR1_Attr7_Pos) /*!< MPU MAIR1: Attr7 Mask */ + +#define MPU_MAIR1_Attr6_Pos 16U /*!< MPU MAIR1: Attr6 Position */ +#define MPU_MAIR1_Attr6_Msk (0xFFUL << MPU_MAIR1_Attr6_Pos) /*!< MPU MAIR1: Attr6 Mask */ + +#define MPU_MAIR1_Attr5_Pos 8U /*!< MPU MAIR1: Attr5 Position */ +#define MPU_MAIR1_Attr5_Msk (0xFFUL << MPU_MAIR1_Attr5_Pos) /*!< MPU MAIR1: Attr5 Mask */ + +#define MPU_MAIR1_Attr4_Pos 0U /*!< MPU MAIR1: Attr4 Position */ +#define MPU_MAIR1_Attr4_Msk (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/) /*!< MPU MAIR1: Attr4 Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SAU Security Attribution Unit (SAU) + \brief Type definitions for the Security Attribution Unit (SAU) + @{ + */ + +/** + \brief Structure type to access the Security Attribution Unit (SAU). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SAU Control Register */ + __IM uint32_t TYPE; /*!< Offset: 0x004 (R/ ) SAU Type Register */ +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) SAU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) SAU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) SAU Region Limit Address Register */ +#endif +} SAU_Type; + +/* SAU Control Register Definitions */ +#define SAU_CTRL_ALLNS_Pos 1U /*!< SAU CTRL: ALLNS Position */ +#define SAU_CTRL_ALLNS_Msk (1UL << SAU_CTRL_ALLNS_Pos) /*!< SAU CTRL: ALLNS Mask */ + +#define SAU_CTRL_ENABLE_Pos 0U /*!< SAU CTRL: ENABLE Position */ +#define SAU_CTRL_ENABLE_Msk (1UL /*<< SAU_CTRL_ENABLE_Pos*/) /*!< SAU CTRL: ENABLE Mask */ + +/* SAU Type Register Definitions */ +#define SAU_TYPE_SREGION_Pos 0U /*!< SAU TYPE: SREGION Position */ +#define SAU_TYPE_SREGION_Msk (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/) /*!< SAU TYPE: SREGION Mask */ + +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) +/* SAU Region Number Register Definitions */ +#define SAU_RNR_REGION_Pos 0U /*!< SAU RNR: REGION Position */ +#define SAU_RNR_REGION_Msk (0xFFUL /*<< SAU_RNR_REGION_Pos*/) /*!< SAU RNR: REGION Mask */ + +/* SAU Region Base Address Register Definitions */ +#define SAU_RBAR_BADDR_Pos 5U /*!< SAU RBAR: BADDR Position */ +#define SAU_RBAR_BADDR_Msk (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos) /*!< SAU RBAR: BADDR Mask */ + +/* SAU Region Limit Address Register Definitions */ +#define SAU_RLAR_LADDR_Pos 5U /*!< SAU RLAR: LADDR Position */ +#define SAU_RLAR_LADDR_Msk (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos) /*!< SAU RLAR: LADDR Mask */ + +#define SAU_RLAR_NSC_Pos 1U /*!< SAU RLAR: NSC Position */ +#define SAU_RLAR_NSC_Msk (1UL << SAU_RLAR_NSC_Pos) /*!< SAU RLAR: NSC Mask */ + +#define SAU_RLAR_ENABLE_Pos 0U /*!< SAU RLAR: ENABLE Position */ +#define SAU_RLAR_ENABLE_Msk (1UL /*<< SAU_RLAR_ENABLE_Pos*/) /*!< SAU RLAR: ENABLE Mask */ + +#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */ + +/*@} end of group CMSIS_SAU */ +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ + uint32_t RESERVED4[1U]; + __IOM uint32_t DAUTHCTRL; /*!< Offset: 0x014 (R/W) Debug Authentication Control Register */ + __IOM uint32_t DSCSR; /*!< Offset: 0x018 (R/W) Debug Security Control and Status Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESTART_ST_Pos 26U /*!< CoreDebug DHCSR: S_RESTART_ST Position */ +#define CoreDebug_DHCSR_S_RESTART_ST_Msk (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos) /*!< CoreDebug DHCSR: S_RESTART_ST Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register */ +#define CoreDebug_DEMCR_DWTENA_Pos 24U /*!< CoreDebug DEMCR: DWTENA Position */ +#define CoreDebug_DEMCR_DWTENA_Msk (1UL << CoreDebug_DEMCR_DWTENA_Pos) /*!< CoreDebug DEMCR: DWTENA Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/* Debug Authentication Control Register Definitions */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos 3U /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */ + +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos 2U /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos) /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */ + +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos 1U /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */ +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */ + +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos 0U /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */ + +/* Debug Security Control and Status Register Definitions */ +#define CoreDebug_DSCSR_CDS_Pos 16U /*!< CoreDebug DSCSR: CDS Position */ +#define CoreDebug_DSCSR_CDS_Msk (1UL << CoreDebug_DSCSR_CDS_Pos) /*!< CoreDebug DSCSR: CDS Mask */ + +#define CoreDebug_DSCSR_SBRSEL_Pos 1U /*!< CoreDebug DSCSR: SBRSEL Position */ +#define CoreDebug_DSCSR_SBRSEL_Msk (1UL << CoreDebug_DSCSR_SBRSEL_Pos) /*!< CoreDebug DSCSR: SBRSEL Mask */ + +#define CoreDebug_DSCSR_SBRSELEN_Pos 0U /*!< CoreDebug DSCSR: SBRSELEN Position */ +#define CoreDebug_DSCSR_SBRSELEN_Msk (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/) /*!< CoreDebug DSCSR: SBRSELEN Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ + #define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ + #define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ + #define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ + #define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ + #define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ + #define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ + #define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + + + #define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ + #define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ + #define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + #define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ + #define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ + #define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE ) /*!< Core Debug configuration struct */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ + #endif + + #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SAU_BASE (SCS_BASE + 0x0DD0UL) /*!< Security Attribution Unit */ + #define SAU ((SAU_Type *) SAU_BASE ) /*!< Security Attribution Unit */ + #endif + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SCS_BASE_NS (0xE002E000UL) /*!< System Control Space Base Address (non-secure address space) */ + #define CoreDebug_BASE_NS (0xE002EDF0UL) /*!< Core Debug Base Address (non-secure address space) */ + #define SysTick_BASE_NS (SCS_BASE_NS + 0x0010UL) /*!< SysTick Base Address (non-secure address space) */ + #define NVIC_BASE_NS (SCS_BASE_NS + 0x0100UL) /*!< NVIC Base Address (non-secure address space) */ + #define SCB_BASE_NS (SCS_BASE_NS + 0x0D00UL) /*!< System Control Block Base Address (non-secure address space) */ + + #define SCB_NS ((SCB_Type *) SCB_BASE_NS ) /*!< SCB configuration struct (non-secure address space) */ + #define SysTick_NS ((SysTick_Type *) SysTick_BASE_NS ) /*!< SysTick configuration struct (non-secure address space) */ + #define NVIC_NS ((NVIC_Type *) NVIC_BASE_NS ) /*!< NVIC configuration struct (non-secure address space) */ + #define CoreDebug_NS ((CoreDebug_Type *) CoreDebug_BASE_NS) /*!< Core Debug configuration struct (non-secure address space) */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE_NS (SCS_BASE_NS + 0x0D90UL) /*!< Memory Protection Unit (non-secure address space) */ + #define MPU_NS ((MPU_Type *) MPU_BASE_NS ) /*!< Memory Protection Unit (non-secure address space) */ + #endif + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else +/*#define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping not available for Cortex-M23 */ +/*#define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping not available for Cortex-M23 */ + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* Special LR values for Secure/Non-Secure call handling and exception handling */ + +/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS */ +#define FNC_RETURN (0xFEFFFFFFUL) /* bit [0] ignored when processing a branch */ + +/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */ +#define EXC_RETURN_PREFIX (0xFF000000UL) /* bits [31:24] set to indicate an EXC_RETURN value */ +#define EXC_RETURN_S (0x00000040UL) /* bit [6] stack used to push registers: 0=Non-secure 1=Secure */ +#define EXC_RETURN_DCRS (0x00000020UL) /* bit [5] stacking rules for called registers: 0=skipped 1=saved */ +#define EXC_RETURN_FTYPE (0x00000010UL) /* bit [4] allocate stack for floating-point context: 0=done 1=skipped */ +#define EXC_RETURN_MODE (0x00000008UL) /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode */ +#define EXC_RETURN_SPSEL (0x00000004UL) /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP */ +#define EXC_RETURN_ES (0x00000001UL) /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */ + +/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking */ +#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) /* Value for processors with floating-point extension: */ +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125AUL) /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE */ +#else +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125BUL) /* Value for processors without floating-point extension */ +#endif + + +/* Interrupt Priorities are WORD accessible only under Armv6-M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( ((((uint32_t)(int32_t)(IRQn)) ) & 0x03UL) * 8UL) +#define _SHP_IDX(IRQn) ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >> 2UL) ) +#define _IP_IDX(IRQn) ( (((uint32_t)(int32_t)(IRQn)) >> 2UL) ) + +#define __NVIC_SetPriorityGrouping(X) (void)(X) +#define __NVIC_GetPriorityGrouping() (0U) + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Get Interrupt Target State + \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + \return 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Target State + \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |= ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Clear Interrupt Target State + \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IPR[_IP_IDX(IRQn)] = ((uint32_t)(NVIC->IPR[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + If VTOR is not present address 0 must be mapped to SRAM. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + uint32_t *vectors = (uint32_t *)SCB->VTOR; +#else + uint32_t *vectors = (uint32_t *)0x0U; +#endif + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + __DSB(); +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + uint32_t *vectors = (uint32_t *)SCB->VTOR; +#else + uint32_t *vectors = (uint32_t *)0x0U; +#endif + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Enable Interrupt (non-secure) + \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Interrupt Enable status (non-secure) + \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt (non-secure) + \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Pending Interrupt (non-secure) + \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt (non-secure) + \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt (non-secure) + \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt (non-secure) + \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority (non-secure) + \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every non-secure processor exception. + */ +__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->IPR[_IP_IDX(IRQn)] = ((uint32_t)(NVIC_NS->IPR[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB_NS->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB_NS->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority (non-secure) + \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB_NS->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv8.h" + +#endif + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ########################## SAU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SAUFunctions SAU Functions + \brief Functions that configure the SAU. + @{ + */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + +/** + \brief Enable SAU + \details Enables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Enable(void) +{ + SAU->CTRL |= (SAU_CTRL_ENABLE_Msk); +} + + + +/** + \brief Disable SAU + \details Disables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Disable(void) +{ + SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk); +} + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_SAUFunctions */ + + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief System Tick Configuration (non-secure) + \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function TZ_SysTick_Config_NS is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick_NS->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick_NS->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick_NS->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM23_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm3.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm3.h new file mode 100644 index 0000000000..8157ca782d --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm3.h @@ -0,0 +1,1937 @@ +/**************************************************************************//** + * @file core_cm3.h + * @brief CMSIS Cortex-M3 Core Peripheral Access Layer Header File + * @version V5.1.0 + * @date 13. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM3_H_GENERIC +#define __CORE_CM3_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M3 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM3 definitions */ +#define __CM3_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM3_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM3_CMSIS_VERSION ((__CM3_CMSIS_VERSION_MAIN << 16U) | \ + __CM3_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (3U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM3_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM3_H_DEPENDANT +#define __CORE_CM3_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM3_REV + #define __CM3_REV 0x0200U + #warning "__CM3_REV not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M3 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:27; /*!< bit: 0..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:1; /*!< bit: 9 Reserved */ + uint32_t ICI_IT_1:6; /*!< bit: 10..15 ICI/IT part 1 */ + uint32_t _reserved1:8; /*!< bit: 16..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit */ + uint32_t ICI_IT_2:2; /*!< bit: 25..26 ICI/IT part 2 */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_ICI_IT_2_Pos 25U /*!< xPSR: ICI/IT part 2 Position */ +#define xPSR_ICI_IT_2_Msk (3UL << xPSR_ICI_IT_2_Pos) /*!< xPSR: ICI/IT part 2 Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ICI_IT_1_Pos 10U /*!< xPSR: ICI/IT part 1 Position */ +#define xPSR_ICI_IT_1_Msk (0x3FUL << xPSR_ICI_IT_1_Pos) /*!< xPSR: ICI/IT part 1 Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[8U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[24U]; + __IOM uint32_t ICER[8U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RESERVED1[24U]; + __IOM uint32_t ISPR[8U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[24U]; + __IOM uint32_t ICPR[8U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[24U]; + __IOM uint32_t IABR[8U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[56U]; + __IOM uint8_t IP[240U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED5[644U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHP[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ISAR[5U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + uint32_t RESERVED0[5U]; + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#if defined (__CM3_REV) && (__CM3_REV < 0x0201U) /* core r2p1 */ +#define SCB_VTOR_TBLBASE_Pos 29U /*!< SCB VTOR: TBLBASE Position */ +#define SCB_VTOR_TBLBASE_Msk (1UL << SCB_VTOR_TBLBASE_Pos) /*!< SCB VTOR: TBLBASE Mask */ + +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x3FFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ +#else +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ +#endif + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +#define SCB_AIRCR_VECTRESET_Pos 0U /*!< SCB AIRCR: VECTRESET Position */ +#define SCB_AIRCR_VECTRESET_Msk (1UL /*<< SCB_AIRCR_VECTRESET_Pos*/) /*!< SCB AIRCR: VECTRESET Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +#define SCB_CCR_NONBASETHRDENA_Pos 0U /*!< SCB CCR: NONBASETHRDENA Position */ +#define SCB_CCR_NONBASETHRDENA_Msk (1UL /*<< SCB_CCR_NONBASETHRDENA_Pos*/) /*!< SCB CCR: NONBASETHRDENA Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ +#if defined (__CM3_REV) && (__CM3_REV >= 0x200U) + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ +#else + uint32_t RESERVED1[1U]; +#endif +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/* Auxiliary Control Register Definitions */ +#if defined (__CM3_REV) && (__CM3_REV >= 0x200U) +#define SCnSCB_ACTLR_DISOOFP_Pos 9U /*!< ACTLR: DISOOFP Position */ +#define SCnSCB_ACTLR_DISOOFP_Msk (1UL << SCnSCB_ACTLR_DISOOFP_Pos) /*!< ACTLR: DISOOFP Mask */ + +#define SCnSCB_ACTLR_DISFPCA_Pos 8U /*!< ACTLR: DISFPCA Position */ +#define SCnSCB_ACTLR_DISFPCA_Msk (1UL << SCnSCB_ACTLR_DISFPCA_Pos) /*!< ACTLR: DISFPCA Mask */ + +#define SCnSCB_ACTLR_DISFOLD_Pos 2U /*!< ACTLR: DISFOLD Position */ +#define SCnSCB_ACTLR_DISFOLD_Msk (1UL << SCnSCB_ACTLR_DISFOLD_Pos) /*!< ACTLR: DISFOLD Mask */ + +#define SCnSCB_ACTLR_DISDEFWBUF_Pos 1U /*!< ACTLR: DISDEFWBUF Position */ +#define SCnSCB_ACTLR_DISDEFWBUF_Msk (1UL << SCnSCB_ACTLR_DISDEFWBUF_Pos) /*!< ACTLR: DISDEFWBUF Mask */ + +#define SCnSCB_ACTLR_DISMCYCINT_Pos 0U /*!< ACTLR: DISMCYCINT Position */ +#define SCnSCB_ACTLR_DISMCYCINT_Msk (1UL /*<< SCnSCB_ACTLR_DISMCYCINT_Pos*/) /*!< ACTLR: DISMCYCINT Mask */ +#endif + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[32U]; + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[6U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TraceBusID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TraceBusID_Msk (0x7FUL << ITM_TCR_TraceBusID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPrescale_Pos 8U /*!< ITM TCR: TSPrescale Position */ +#define ITM_TCR_TSPrescale_Msk (3UL << ITM_TCR_TSPrescale_Pos) /*!< ITM TCR: TSPrescale Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + __IOM uint32_t MASK0; /*!< Offset: 0x024 (R/W) Mask Register 0 */ + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED0[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + __IOM uint32_t MASK1; /*!< Offset: 0x034 (R/W) Mask Register 1 */ + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + __IOM uint32_t MASK2; /*!< Offset: 0x044 (R/W) Mask Register 2 */ + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + __IOM uint32_t MASK3; /*!< Offset: 0x054 (R/W) Mask Register 3 */ + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Mask Register Definitions */ +#define DWT_MASK_MASK_Pos 0U /*!< DWT MASK: MASK Position */ +#define DWT_MASK_MASK_Msk (0x1FUL /*<< DWT_MASK_MASK_Pos*/) /*!< DWT MASK: MASK Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVADDR1_Pos 16U /*!< DWT FUNCTION: DATAVADDR1 Position */ +#define DWT_FUNCTION_DATAVADDR1_Msk (0xFUL << DWT_FUNCTION_DATAVADDR1_Pos) /*!< DWT FUNCTION: DATAVADDR1 Mask */ + +#define DWT_FUNCTION_DATAVADDR0_Pos 12U /*!< DWT FUNCTION: DATAVADDR0 Position */ +#define DWT_FUNCTION_DATAVADDR0_Msk (0xFUL << DWT_FUNCTION_DATAVADDR0_Pos) /*!< DWT FUNCTION: DATAVADDR0 Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_LNK1ENA_Pos 9U /*!< DWT FUNCTION: LNK1ENA Position */ +#define DWT_FUNCTION_LNK1ENA_Msk (0x1UL << DWT_FUNCTION_LNK1ENA_Pos) /*!< DWT FUNCTION: LNK1ENA Mask */ + +#define DWT_FUNCTION_DATAVMATCH_Pos 8U /*!< DWT FUNCTION: DATAVMATCH Position */ +#define DWT_FUNCTION_DATAVMATCH_Msk (0x1UL << DWT_FUNCTION_DATAVMATCH_Pos) /*!< DWT FUNCTION: DATAVMATCH Mask */ + +#define DWT_FUNCTION_CYCMATCH_Pos 7U /*!< DWT FUNCTION: CYCMATCH Position */ +#define DWT_FUNCTION_CYCMATCH_Msk (0x1UL << DWT_FUNCTION_CYCMATCH_Pos) /*!< DWT FUNCTION: CYCMATCH Mask */ + +#define DWT_FUNCTION_EMITRANGE_Pos 5U /*!< DWT FUNCTION: EMITRANGE Position */ +#define DWT_FUNCTION_EMITRANGE_Msk (0x1UL << DWT_FUNCTION_EMITRANGE_Pos) /*!< DWT FUNCTION: EMITRANGE Mask */ + +#define DWT_FUNCTION_FUNCTION_Pos 0U /*!< DWT FUNCTION: FUNCTION Position */ +#define DWT_FUNCTION_FUNCTION_Msk (0xFUL /*<< DWT_FUNCTION_FUNCTION_Pos*/) /*!< DWT FUNCTION: FUNCTION Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IM uint32_t FSCR; /*!< Offset: 0x308 (R/ ) Formatter Synchronization Counter Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER Register */ + __IM uint32_t FIFO0; /*!< Offset: 0xEEC (R/ ) Integration ETM Data */ + __IM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/ ) ITATBCTR2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) ITATBCTR0 */ + __IM uint32_t FIFO1; /*!< Offset: 0xEFC (R/ ) Integration ITM Data */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) TPIU_DEVID */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) TPIU_DEVTYPE */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration ETM Data Register Definitions (FIFO0) */ +#define TPI_FIFO0_ITM_ATVALID_Pos 29U /*!< TPI FIFO0: ITM_ATVALID Position */ +#define TPI_FIFO0_ITM_ATVALID_Msk (0x1UL << TPI_FIFO0_ITM_ATVALID_Pos) /*!< TPI FIFO0: ITM_ATVALID Mask */ + +#define TPI_FIFO0_ITM_bytecount_Pos 27U /*!< TPI FIFO0: ITM_bytecount Position */ +#define TPI_FIFO0_ITM_bytecount_Msk (0x3UL << TPI_FIFO0_ITM_bytecount_Pos) /*!< TPI FIFO0: ITM_bytecount Mask */ + +#define TPI_FIFO0_ETM_ATVALID_Pos 26U /*!< TPI FIFO0: ETM_ATVALID Position */ +#define TPI_FIFO0_ETM_ATVALID_Msk (0x1UL << TPI_FIFO0_ETM_ATVALID_Pos) /*!< TPI FIFO0: ETM_ATVALID Mask */ + +#define TPI_FIFO0_ETM_bytecount_Pos 24U /*!< TPI FIFO0: ETM_bytecount Position */ +#define TPI_FIFO0_ETM_bytecount_Msk (0x3UL << TPI_FIFO0_ETM_bytecount_Pos) /*!< TPI FIFO0: ETM_bytecount Mask */ + +#define TPI_FIFO0_ETM2_Pos 16U /*!< TPI FIFO0: ETM2 Position */ +#define TPI_FIFO0_ETM2_Msk (0xFFUL << TPI_FIFO0_ETM2_Pos) /*!< TPI FIFO0: ETM2 Mask */ + +#define TPI_FIFO0_ETM1_Pos 8U /*!< TPI FIFO0: ETM1 Position */ +#define TPI_FIFO0_ETM1_Msk (0xFFUL << TPI_FIFO0_ETM1_Pos) /*!< TPI FIFO0: ETM1 Mask */ + +#define TPI_FIFO0_ETM0_Pos 0U /*!< TPI FIFO0: ETM0 Position */ +#define TPI_FIFO0_ETM0_Msk (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/) /*!< TPI FIFO0: ETM0 Mask */ + +/* TPI ITATBCTR2 Register Definitions */ +#define TPI_ITATBCTR2_ATREADY2_Pos 0U /*!< TPI ITATBCTR2: ATREADY2 Position */ +#define TPI_ITATBCTR2_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/) /*!< TPI ITATBCTR2: ATREADY2 Mask */ + +#define TPI_ITATBCTR2_ATREADY1_Pos 0U /*!< TPI ITATBCTR2: ATREADY1 Position */ +#define TPI_ITATBCTR2_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/) /*!< TPI ITATBCTR2: ATREADY1 Mask */ + +/* TPI Integration ITM Data Register Definitions (FIFO1) */ +#define TPI_FIFO1_ITM_ATVALID_Pos 29U /*!< TPI FIFO1: ITM_ATVALID Position */ +#define TPI_FIFO1_ITM_ATVALID_Msk (0x1UL << TPI_FIFO1_ITM_ATVALID_Pos) /*!< TPI FIFO1: ITM_ATVALID Mask */ + +#define TPI_FIFO1_ITM_bytecount_Pos 27U /*!< TPI FIFO1: ITM_bytecount Position */ +#define TPI_FIFO1_ITM_bytecount_Msk (0x3UL << TPI_FIFO1_ITM_bytecount_Pos) /*!< TPI FIFO1: ITM_bytecount Mask */ + +#define TPI_FIFO1_ETM_ATVALID_Pos 26U /*!< TPI FIFO1: ETM_ATVALID Position */ +#define TPI_FIFO1_ETM_ATVALID_Msk (0x1UL << TPI_FIFO1_ETM_ATVALID_Pos) /*!< TPI FIFO1: ETM_ATVALID Mask */ + +#define TPI_FIFO1_ETM_bytecount_Pos 24U /*!< TPI FIFO1: ETM_bytecount Position */ +#define TPI_FIFO1_ETM_bytecount_Msk (0x3UL << TPI_FIFO1_ETM_bytecount_Pos) /*!< TPI FIFO1: ETM_bytecount Mask */ + +#define TPI_FIFO1_ITM2_Pos 16U /*!< TPI FIFO1: ITM2 Position */ +#define TPI_FIFO1_ITM2_Msk (0xFFUL << TPI_FIFO1_ITM2_Pos) /*!< TPI FIFO1: ITM2 Mask */ + +#define TPI_FIFO1_ITM1_Pos 8U /*!< TPI FIFO1: ITM1 Position */ +#define TPI_FIFO1_ITM1_Msk (0xFFUL << TPI_FIFO1_ITM1_Pos) /*!< TPI FIFO1: ITM1 Mask */ + +#define TPI_FIFO1_ITM0_Pos 0U /*!< TPI FIFO1: ITM0 Position */ +#define TPI_FIFO1_ITM0_Msk (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/) /*!< TPI FIFO1: ITM0 Mask */ + +/* TPI ITATBCTR0 Register Definitions */ +#define TPI_ITATBCTR0_ATREADY2_Pos 0U /*!< TPI ITATBCTR0: ATREADY2 Position */ +#define TPI_ITATBCTR0_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/) /*!< TPI ITATBCTR0: ATREADY2 Mask */ + +#define TPI_ITATBCTR0_ATREADY1_Pos 0U /*!< TPI ITATBCTR0: ATREADY1 Position */ +#define TPI_ITATBCTR0_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/) /*!< TPI ITATBCTR0: ATREADY1 Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_MinBufSz_Pos 6U /*!< TPI DEVID: MinBufSz Position */ +#define TPI_DEVID_MinBufSz_Msk (0x7UL << TPI_DEVID_MinBufSz_Pos) /*!< TPI DEVID: MinBufSz Mask */ + +#define TPI_DEVID_AsynClkIn_Pos 5U /*!< TPI DEVID: AsynClkIn Position */ +#define TPI_DEVID_AsynClkIn_Msk (0x1UL << TPI_DEVID_AsynClkIn_Pos) /*!< TPI DEVID: AsynClkIn Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region RNRber Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RASR; /*!< Offset: 0x010 (R/W) MPU Region Attribute and Size Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Alias 1 Region Base Address Register */ + __IOM uint32_t RASR_A1; /*!< Offset: 0x018 (R/W) MPU Alias 1 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Alias 2 Region Base Address Register */ + __IOM uint32_t RASR_A2; /*!< Offset: 0x020 (R/W) MPU Alias 2 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Alias 3 Region Base Address Register */ + __IOM uint32_t RASR_A3; /*!< Offset: 0x028 (R/W) MPU Alias 3 Region Attribute and Size Register */ +} MPU_Type; + +#define MPU_TYPE_RALIASES 4U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_ADDR_Pos 5U /*!< MPU RBAR: ADDR Position */ +#define MPU_RBAR_ADDR_Msk (0x7FFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */ + +#define MPU_RBAR_VALID_Pos 4U /*!< MPU RBAR: VALID Position */ +#define MPU_RBAR_VALID_Msk (1UL << MPU_RBAR_VALID_Pos) /*!< MPU RBAR: VALID Mask */ + +#define MPU_RBAR_REGION_Pos 0U /*!< MPU RBAR: REGION Position */ +#define MPU_RBAR_REGION_Msk (0xFUL /*<< MPU_RBAR_REGION_Pos*/) /*!< MPU RBAR: REGION Mask */ + +/* MPU Region Attribute and Size Register Definitions */ +#define MPU_RASR_ATTRS_Pos 16U /*!< MPU RASR: MPU Region Attribute field Position */ +#define MPU_RASR_ATTRS_Msk (0xFFFFUL << MPU_RASR_ATTRS_Pos) /*!< MPU RASR: MPU Region Attribute field Mask */ + +#define MPU_RASR_XN_Pos 28U /*!< MPU RASR: ATTRS.XN Position */ +#define MPU_RASR_XN_Msk (1UL << MPU_RASR_XN_Pos) /*!< MPU RASR: ATTRS.XN Mask */ + +#define MPU_RASR_AP_Pos 24U /*!< MPU RASR: ATTRS.AP Position */ +#define MPU_RASR_AP_Msk (0x7UL << MPU_RASR_AP_Pos) /*!< MPU RASR: ATTRS.AP Mask */ + +#define MPU_RASR_TEX_Pos 19U /*!< MPU RASR: ATTRS.TEX Position */ +#define MPU_RASR_TEX_Msk (0x7UL << MPU_RASR_TEX_Pos) /*!< MPU RASR: ATTRS.TEX Mask */ + +#define MPU_RASR_S_Pos 18U /*!< MPU RASR: ATTRS.S Position */ +#define MPU_RASR_S_Msk (1UL << MPU_RASR_S_Pos) /*!< MPU RASR: ATTRS.S Mask */ + +#define MPU_RASR_C_Pos 17U /*!< MPU RASR: ATTRS.C Position */ +#define MPU_RASR_C_Msk (1UL << MPU_RASR_C_Pos) /*!< MPU RASR: ATTRS.C Mask */ + +#define MPU_RASR_B_Pos 16U /*!< MPU RASR: ATTRS.B Position */ +#define MPU_RASR_B_Msk (1UL << MPU_RASR_B_Pos) /*!< MPU RASR: ATTRS.B Mask */ + +#define MPU_RASR_SRD_Pos 8U /*!< MPU RASR: Sub-Region Disable Position */ +#define MPU_RASR_SRD_Msk (0xFFUL << MPU_RASR_SRD_Pos) /*!< MPU RASR: Sub-Region Disable Mask */ + +#define MPU_RASR_SIZE_Pos 1U /*!< MPU RASR: Region Size Field Position */ +#define MPU_RASR_SIZE_Msk (0x1FUL << MPU_RASR_SIZE_Pos) /*!< MPU RASR: Region Size Field Mask */ + +#define MPU_RASR_ENABLE_Pos 0U /*!< MPU RASR: Region enable bit Position */ +#define MPU_RASR_ENABLE_Msk (1UL /*<< MPU_RASR_ENABLE_Pos*/) /*!< MPU RASR: Region enable bit Disable Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ +#define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ +#define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ +#define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ +#define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ +#define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ +#define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ +#define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE) /*!< Core Debug configuration struct */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ +#endif + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IP[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector; + /* ARM Application Note 321 states that the M3 does not require the architectural barrier */ +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)); +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv7.h" + +#endif + + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM3_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm33.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm33.h new file mode 100644 index 0000000000..7fed59a88e --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm33.h @@ -0,0 +1,2910 @@ +/**************************************************************************//** + * @file core_cm33.h + * @brief CMSIS Cortex-M33 Core Peripheral Access Layer Header File + * @version V5.1.0 + * @date 12. November 2018 + ******************************************************************************/ +/* + * Copyright (c) 2009-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM33_H_GENERIC +#define __CORE_CM33_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M33 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM33 definitions */ +#define __CM33_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM33_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM33_CMSIS_VERSION ((__CM33_CMSIS_VERSION_MAIN << 16U) | \ + __CM33_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (33U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions. +*/ +#if defined ( __CC_ARM ) + #if defined (__TARGET_FPU_VFP) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined (__ARM_FP) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __ICCARM__ ) + #if defined (__ARMVFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __TI_ARM__ ) + #if defined (__TI_VFP_SUPPORT__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TASKING__ ) + #if defined (__FPU_VFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM33_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM33_H_DEPENDANT +#define __CORE_CM33_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM33_REV + #define __CM33_REV 0x0000U + #warning "__CM33_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __SAUREGION_PRESENT + #define __SAUREGION_PRESENT 0U + #warning "__SAUREGION_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __DSP_PRESENT + #define __DSP_PRESENT 0U + #warning "__DSP_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M33 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core SAU Register + - Core FPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + +#define APSR_GE_Pos 16U /*!< APSR: GE Position */ +#define APSR_GE_Msk (0xFUL << APSR_GE_Pos) /*!< APSR: GE Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:7; /*!< bit: 9..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t IT:2; /*!< bit: 25..26 saved IT state (read 0) */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_IT_Pos 25U /*!< xPSR: IT Position */ +#define xPSR_IT_Msk (3UL << xPSR_IT_Pos) /*!< xPSR: IT Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_GE_Pos 16U /*!< xPSR: GE Position */ +#define xPSR_GE_Msk (0xFUL << xPSR_GE_Pos) /*!< xPSR: GE Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack-pointer select */ + uint32_t FPCA:1; /*!< bit: 2 Floating-point context active */ + uint32_t SFPA:1; /*!< bit: 3 Secure floating-point active */ + uint32_t _reserved1:28; /*!< bit: 4..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SFPA_Pos 3U /*!< CONTROL: SFPA Position */ +#define CONTROL_SFPA_Msk (1UL << CONTROL_SFPA_Pos) /*!< CONTROL: SFPA Mask */ + +#define CONTROL_FPCA_Pos 2U /*!< CONTROL: FPCA Position */ +#define CONTROL_FPCA_Msk (1UL << CONTROL_FPCA_Pos) /*!< CONTROL: FPCA Mask */ + +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[16U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[16U]; + __IOM uint32_t ICER[16U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[16U]; + __IOM uint32_t ISPR[16U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[16U]; + __IOM uint32_t ICPR[16U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[16U]; + __IOM uint32_t IABR[16U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[16U]; + __IOM uint32_t ITNS[16U]; /*!< Offset: 0x280 (R/W) Interrupt Non-Secure State Register */ + uint32_t RESERVED5[16U]; + __IOM uint8_t IPR[496U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED6[580U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHPR[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t ID_PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t ID_DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ID_ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t ID_MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ID_ISAR[6U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + __IM uint32_t CLIDR; /*!< Offset: 0x078 (R/ ) Cache Level ID register */ + __IM uint32_t CTR; /*!< Offset: 0x07C (R/ ) Cache Type register */ + __IM uint32_t CCSIDR; /*!< Offset: 0x080 (R/ ) Cache Size ID Register */ + __IOM uint32_t CSSELR; /*!< Offset: 0x084 (R/W) Cache Size Selection Register */ + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ + __IOM uint32_t NSACR; /*!< Offset: 0x08C (R/W) Non-Secure Access Control Register */ + uint32_t RESERVED3[92U]; + __OM uint32_t STIR; /*!< Offset: 0x200 ( /W) Software Triggered Interrupt Register */ + uint32_t RESERVED4[15U]; + __IM uint32_t MVFR0; /*!< Offset: 0x240 (R/ ) Media and VFP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x244 (R/ ) Media and VFP Feature Register 1 */ + __IM uint32_t MVFR2; /*!< Offset: 0x248 (R/ ) Media and VFP Feature Register 2 */ + uint32_t RESERVED5[1U]; + __OM uint32_t ICIALLU; /*!< Offset: 0x250 ( /W) I-Cache Invalidate All to PoU */ + uint32_t RESERVED6[1U]; + __OM uint32_t ICIMVAU; /*!< Offset: 0x258 ( /W) I-Cache Invalidate by MVA to PoU */ + __OM uint32_t DCIMVAC; /*!< Offset: 0x25C ( /W) D-Cache Invalidate by MVA to PoC */ + __OM uint32_t DCISW; /*!< Offset: 0x260 ( /W) D-Cache Invalidate by Set-way */ + __OM uint32_t DCCMVAU; /*!< Offset: 0x264 ( /W) D-Cache Clean by MVA to PoU */ + __OM uint32_t DCCMVAC; /*!< Offset: 0x268 ( /W) D-Cache Clean by MVA to PoC */ + __OM uint32_t DCCSW; /*!< Offset: 0x26C ( /W) D-Cache Clean by Set-way */ + __OM uint32_t DCCIMVAC; /*!< Offset: 0x270 ( /W) D-Cache Clean and Invalidate by MVA to PoC */ + __OM uint32_t DCCISW; /*!< Offset: 0x274 ( /W) D-Cache Clean and Invalidate by Set-way */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_PENDNMISET_Pos 31U /*!< SCB ICSR: PENDNMISET Position */ +#define SCB_ICSR_PENDNMISET_Msk (1UL << SCB_ICSR_PENDNMISET_Pos) /*!< SCB ICSR: PENDNMISET Mask */ + +#define SCB_ICSR_NMIPENDSET_Pos SCB_ICSR_PENDNMISET_Pos /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */ +#define SCB_ICSR_NMIPENDSET_Msk SCB_ICSR_PENDNMISET_Msk /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */ + +#define SCB_ICSR_PENDNMICLR_Pos 30U /*!< SCB ICSR: PENDNMICLR Position */ +#define SCB_ICSR_PENDNMICLR_Msk (1UL << SCB_ICSR_PENDNMICLR_Pos) /*!< SCB ICSR: PENDNMICLR Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_STTNS_Pos 24U /*!< SCB ICSR: STTNS Position (Security Extension) */ +#define SCB_ICSR_STTNS_Msk (1UL << SCB_ICSR_STTNS_Pos) /*!< SCB ICSR: STTNS Mask (Security Extension) */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIS_Pos 14U /*!< SCB AIRCR: PRIS Position */ +#define SCB_AIRCR_PRIS_Msk (1UL << SCB_AIRCR_PRIS_Pos) /*!< SCB AIRCR: PRIS Mask */ + +#define SCB_AIRCR_BFHFNMINS_Pos 13U /*!< SCB AIRCR: BFHFNMINS Position */ +#define SCB_AIRCR_BFHFNMINS_Msk (1UL << SCB_AIRCR_BFHFNMINS_Pos) /*!< SCB AIRCR: BFHFNMINS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQS_Pos 3U /*!< SCB AIRCR: SYSRESETREQS Position */ +#define SCB_AIRCR_SYSRESETREQS_Msk (1UL << SCB_AIRCR_SYSRESETREQS_Pos) /*!< SCB AIRCR: SYSRESETREQS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEPS_Pos 3U /*!< SCB SCR: SLEEPDEEPS Position */ +#define SCB_SCR_SLEEPDEEPS_Msk (1UL << SCB_SCR_SLEEPDEEPS_Pos) /*!< SCB SCR: SLEEPDEEPS Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_BP_Pos 18U /*!< SCB CCR: BP Position */ +#define SCB_CCR_BP_Msk (1UL << SCB_CCR_BP_Pos) /*!< SCB CCR: BP Mask */ + +#define SCB_CCR_IC_Pos 17U /*!< SCB CCR: IC Position */ +#define SCB_CCR_IC_Msk (1UL << SCB_CCR_IC_Pos) /*!< SCB CCR: IC Mask */ + +#define SCB_CCR_DC_Pos 16U /*!< SCB CCR: DC Position */ +#define SCB_CCR_DC_Msk (1UL << SCB_CCR_DC_Pos) /*!< SCB CCR: DC Mask */ + +#define SCB_CCR_STKOFHFNMIGN_Pos 10U /*!< SCB CCR: STKOFHFNMIGN Position */ +#define SCB_CCR_STKOFHFNMIGN_Msk (1UL << SCB_CCR_STKOFHFNMIGN_Pos) /*!< SCB CCR: STKOFHFNMIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_HARDFAULTPENDED_Pos 21U /*!< SCB SHCSR: HARDFAULTPENDED Position */ +#define SCB_SHCSR_HARDFAULTPENDED_Msk (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos) /*!< SCB SHCSR: HARDFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTPENDED_Pos 20U /*!< SCB SHCSR: SECUREFAULTPENDED Position */ +#define SCB_SHCSR_SECUREFAULTPENDED_Msk (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos) /*!< SCB SHCSR: SECUREFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTENA_Pos 19U /*!< SCB SHCSR: SECUREFAULTENA Position */ +#define SCB_SHCSR_SECUREFAULTENA_Msk (1UL << SCB_SHCSR_SECUREFAULTENA_Pos) /*!< SCB SHCSR: SECUREFAULTENA Mask */ + +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_NMIACT_Pos 5U /*!< SCB SHCSR: NMIACT Position */ +#define SCB_SHCSR_NMIACT_Msk (1UL << SCB_SHCSR_NMIACT_Pos) /*!< SCB SHCSR: NMIACT Mask */ + +#define SCB_SHCSR_SECUREFAULTACT_Pos 4U /*!< SCB SHCSR: SECUREFAULTACT Position */ +#define SCB_SHCSR_SECUREFAULTACT_Msk (1UL << SCB_SHCSR_SECUREFAULTACT_Pos) /*!< SCB SHCSR: SECUREFAULTACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_HARDFAULTACT_Pos 2U /*!< SCB SHCSR: HARDFAULTACT Position */ +#define SCB_SHCSR_HARDFAULTACT_Msk (1UL << SCB_SHCSR_HARDFAULTACT_Pos) /*!< SCB SHCSR: HARDFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MLSPERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 5U) /*!< SCB CFSR (MMFSR): MLSPERR Position */ +#define SCB_CFSR_MLSPERR_Msk (1UL << SCB_CFSR_MLSPERR_Pos) /*!< SCB CFSR (MMFSR): MLSPERR Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_LSPERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 5U) /*!< SCB CFSR (BFSR): LSPERR Position */ +#define SCB_CFSR_LSPERR_Msk (1UL << SCB_CFSR_LSPERR_Pos) /*!< SCB CFSR (BFSR): LSPERR Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_STKOF_Pos (SCB_CFSR_USGFAULTSR_Pos + 4U) /*!< SCB CFSR (UFSR): STKOF Position */ +#define SCB_CFSR_STKOF_Msk (1UL << SCB_CFSR_STKOF_Pos) /*!< SCB CFSR (UFSR): STKOF Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/* SCB Non-Secure Access Control Register Definitions */ +#define SCB_NSACR_CP11_Pos 11U /*!< SCB NSACR: CP11 Position */ +#define SCB_NSACR_CP11_Msk (1UL << SCB_NSACR_CP11_Pos) /*!< SCB NSACR: CP11 Mask */ + +#define SCB_NSACR_CP10_Pos 10U /*!< SCB NSACR: CP10 Position */ +#define SCB_NSACR_CP10_Msk (1UL << SCB_NSACR_CP10_Pos) /*!< SCB NSACR: CP10 Mask */ + +#define SCB_NSACR_CPn_Pos 0U /*!< SCB NSACR: CPn Position */ +#define SCB_NSACR_CPn_Msk (1UL /*<< SCB_NSACR_CPn_Pos*/) /*!< SCB NSACR: CPn Mask */ + +/* SCB Cache Level ID Register Definitions */ +#define SCB_CLIDR_LOUU_Pos 27U /*!< SCB CLIDR: LoUU Position */ +#define SCB_CLIDR_LOUU_Msk (7UL << SCB_CLIDR_LOUU_Pos) /*!< SCB CLIDR: LoUU Mask */ + +#define SCB_CLIDR_LOC_Pos 24U /*!< SCB CLIDR: LoC Position */ +#define SCB_CLIDR_LOC_Msk (7UL << SCB_CLIDR_LOC_Pos) /*!< SCB CLIDR: LoC Mask */ + +/* SCB Cache Type Register Definitions */ +#define SCB_CTR_FORMAT_Pos 29U /*!< SCB CTR: Format Position */ +#define SCB_CTR_FORMAT_Msk (7UL << SCB_CTR_FORMAT_Pos) /*!< SCB CTR: Format Mask */ + +#define SCB_CTR_CWG_Pos 24U /*!< SCB CTR: CWG Position */ +#define SCB_CTR_CWG_Msk (0xFUL << SCB_CTR_CWG_Pos) /*!< SCB CTR: CWG Mask */ + +#define SCB_CTR_ERG_Pos 20U /*!< SCB CTR: ERG Position */ +#define SCB_CTR_ERG_Msk (0xFUL << SCB_CTR_ERG_Pos) /*!< SCB CTR: ERG Mask */ + +#define SCB_CTR_DMINLINE_Pos 16U /*!< SCB CTR: DminLine Position */ +#define SCB_CTR_DMINLINE_Msk (0xFUL << SCB_CTR_DMINLINE_Pos) /*!< SCB CTR: DminLine Mask */ + +#define SCB_CTR_IMINLINE_Pos 0U /*!< SCB CTR: ImInLine Position */ +#define SCB_CTR_IMINLINE_Msk (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/) /*!< SCB CTR: ImInLine Mask */ + +/* SCB Cache Size ID Register Definitions */ +#define SCB_CCSIDR_WT_Pos 31U /*!< SCB CCSIDR: WT Position */ +#define SCB_CCSIDR_WT_Msk (1UL << SCB_CCSIDR_WT_Pos) /*!< SCB CCSIDR: WT Mask */ + +#define SCB_CCSIDR_WB_Pos 30U /*!< SCB CCSIDR: WB Position */ +#define SCB_CCSIDR_WB_Msk (1UL << SCB_CCSIDR_WB_Pos) /*!< SCB CCSIDR: WB Mask */ + +#define SCB_CCSIDR_RA_Pos 29U /*!< SCB CCSIDR: RA Position */ +#define SCB_CCSIDR_RA_Msk (1UL << SCB_CCSIDR_RA_Pos) /*!< SCB CCSIDR: RA Mask */ + +#define SCB_CCSIDR_WA_Pos 28U /*!< SCB CCSIDR: WA Position */ +#define SCB_CCSIDR_WA_Msk (1UL << SCB_CCSIDR_WA_Pos) /*!< SCB CCSIDR: WA Mask */ + +#define SCB_CCSIDR_NUMSETS_Pos 13U /*!< SCB CCSIDR: NumSets Position */ +#define SCB_CCSIDR_NUMSETS_Msk (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos) /*!< SCB CCSIDR: NumSets Mask */ + +#define SCB_CCSIDR_ASSOCIATIVITY_Pos 3U /*!< SCB CCSIDR: Associativity Position */ +#define SCB_CCSIDR_ASSOCIATIVITY_Msk (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos) /*!< SCB CCSIDR: Associativity Mask */ + +#define SCB_CCSIDR_LINESIZE_Pos 0U /*!< SCB CCSIDR: LineSize Position */ +#define SCB_CCSIDR_LINESIZE_Msk (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/) /*!< SCB CCSIDR: LineSize Mask */ + +/* SCB Cache Size Selection Register Definitions */ +#define SCB_CSSELR_LEVEL_Pos 1U /*!< SCB CSSELR: Level Position */ +#define SCB_CSSELR_LEVEL_Msk (7UL << SCB_CSSELR_LEVEL_Pos) /*!< SCB CSSELR: Level Mask */ + +#define SCB_CSSELR_IND_Pos 0U /*!< SCB CSSELR: InD Position */ +#define SCB_CSSELR_IND_Msk (1UL /*<< SCB_CSSELR_IND_Pos*/) /*!< SCB CSSELR: InD Mask */ + +/* SCB Software Triggered Interrupt Register Definitions */ +#define SCB_STIR_INTID_Pos 0U /*!< SCB STIR: INTID Position */ +#define SCB_STIR_INTID_Msk (0x1FFUL /*<< SCB_STIR_INTID_Pos*/) /*!< SCB STIR: INTID Mask */ + +/* SCB D-Cache Invalidate by Set-way Register Definitions */ +#define SCB_DCISW_WAY_Pos 30U /*!< SCB DCISW: Way Position */ +#define SCB_DCISW_WAY_Msk (3UL << SCB_DCISW_WAY_Pos) /*!< SCB DCISW: Way Mask */ + +#define SCB_DCISW_SET_Pos 5U /*!< SCB DCISW: Set Position */ +#define SCB_DCISW_SET_Msk (0x1FFUL << SCB_DCISW_SET_Pos) /*!< SCB DCISW: Set Mask */ + +/* SCB D-Cache Clean by Set-way Register Definitions */ +#define SCB_DCCSW_WAY_Pos 30U /*!< SCB DCCSW: Way Position */ +#define SCB_DCCSW_WAY_Msk (3UL << SCB_DCCSW_WAY_Pos) /*!< SCB DCCSW: Way Mask */ + +#define SCB_DCCSW_SET_Pos 5U /*!< SCB DCCSW: Set Position */ +#define SCB_DCCSW_SET_Msk (0x1FFUL << SCB_DCCSW_SET_Pos) /*!< SCB DCCSW: Set Mask */ + +/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */ +#define SCB_DCCISW_WAY_Pos 30U /*!< SCB DCCISW: Way Position */ +#define SCB_DCCISW_WAY_Msk (3UL << SCB_DCCISW_WAY_Pos) /*!< SCB DCCISW: Way Mask */ + +#define SCB_DCCISW_SET_Pos 5U /*!< SCB DCCISW: Set Position */ +#define SCB_DCCISW_SET_Msk (0x1FFUL << SCB_DCCISW_SET_Pos) /*!< SCB DCCISW: Set Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ + __IOM uint32_t CPPWR; /*!< Offset: 0x00C (R/W) Coprocessor Power Control Register */ +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[32U]; + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) ITM Device Architecture Register */ + uint32_t RESERVED6[4U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Stimulus Port Register Definitions */ +#define ITM_STIM_DISABLED_Pos 1U /*!< ITM STIM: DISABLED Position */ +#define ITM_STIM_DISABLED_Msk (0x1UL << ITM_STIM_DISABLED_Pos) /*!< ITM STIM: DISABLED Mask */ + +#define ITM_STIM_FIFOREADY_Pos 0U /*!< ITM STIM: FIFOREADY Position */ +#define ITM_STIM_FIFOREADY_Msk (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/) /*!< ITM STIM: FIFOREADY Mask */ + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TRACEBUSID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TRACEBUSID_Msk (0x7FUL << ITM_TCR_TRACEBUSID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPRESCALE_Pos 8U /*!< ITM TCR: TSPRESCALE Position */ +#define ITM_TCR_TSPRESCALE_Msk (3UL << ITM_TCR_TSPRESCALE_Pos) /*!< ITM TCR: TSPRESCALE Mask */ + +#define ITM_TCR_STALLENA_Pos 5U /*!< ITM TCR: STALLENA Position */ +#define ITM_TCR_STALLENA_Msk (1UL << ITM_TCR_STALLENA_Pos) /*!< ITM TCR: STALLENA Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + uint32_t RESERVED3[1U]; + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED4[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + uint32_t RESERVED5[1U]; + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED6[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + uint32_t RESERVED7[1U]; + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ + uint32_t RESERVED8[1U]; + __IOM uint32_t COMP4; /*!< Offset: 0x060 (R/W) Comparator Register 4 */ + uint32_t RESERVED9[1U]; + __IOM uint32_t FUNCTION4; /*!< Offset: 0x068 (R/W) Function Register 4 */ + uint32_t RESERVED10[1U]; + __IOM uint32_t COMP5; /*!< Offset: 0x070 (R/W) Comparator Register 5 */ + uint32_t RESERVED11[1U]; + __IOM uint32_t FUNCTION5; /*!< Offset: 0x078 (R/W) Function Register 5 */ + uint32_t RESERVED12[1U]; + __IOM uint32_t COMP6; /*!< Offset: 0x080 (R/W) Comparator Register 6 */ + uint32_t RESERVED13[1U]; + __IOM uint32_t FUNCTION6; /*!< Offset: 0x088 (R/W) Function Register 6 */ + uint32_t RESERVED14[1U]; + __IOM uint32_t COMP7; /*!< Offset: 0x090 (R/W) Comparator Register 7 */ + uint32_t RESERVED15[1U]; + __IOM uint32_t FUNCTION7; /*!< Offset: 0x098 (R/W) Function Register 7 */ + uint32_t RESERVED16[1U]; + __IOM uint32_t COMP8; /*!< Offset: 0x0A0 (R/W) Comparator Register 8 */ + uint32_t RESERVED17[1U]; + __IOM uint32_t FUNCTION8; /*!< Offset: 0x0A8 (R/W) Function Register 8 */ + uint32_t RESERVED18[1U]; + __IOM uint32_t COMP9; /*!< Offset: 0x0B0 (R/W) Comparator Register 9 */ + uint32_t RESERVED19[1U]; + __IOM uint32_t FUNCTION9; /*!< Offset: 0x0B8 (R/W) Function Register 9 */ + uint32_t RESERVED20[1U]; + __IOM uint32_t COMP10; /*!< Offset: 0x0C0 (R/W) Comparator Register 10 */ + uint32_t RESERVED21[1U]; + __IOM uint32_t FUNCTION10; /*!< Offset: 0x0C8 (R/W) Function Register 10 */ + uint32_t RESERVED22[1U]; + __IOM uint32_t COMP11; /*!< Offset: 0x0D0 (R/W) Comparator Register 11 */ + uint32_t RESERVED23[1U]; + __IOM uint32_t FUNCTION11; /*!< Offset: 0x0D8 (R/W) Function Register 11 */ + uint32_t RESERVED24[1U]; + __IOM uint32_t COMP12; /*!< Offset: 0x0E0 (R/W) Comparator Register 12 */ + uint32_t RESERVED25[1U]; + __IOM uint32_t FUNCTION12; /*!< Offset: 0x0E8 (R/W) Function Register 12 */ + uint32_t RESERVED26[1U]; + __IOM uint32_t COMP13; /*!< Offset: 0x0F0 (R/W) Comparator Register 13 */ + uint32_t RESERVED27[1U]; + __IOM uint32_t FUNCTION13; /*!< Offset: 0x0F8 (R/W) Function Register 13 */ + uint32_t RESERVED28[1U]; + __IOM uint32_t COMP14; /*!< Offset: 0x100 (R/W) Comparator Register 14 */ + uint32_t RESERVED29[1U]; + __IOM uint32_t FUNCTION14; /*!< Offset: 0x108 (R/W) Function Register 14 */ + uint32_t RESERVED30[1U]; + __IOM uint32_t COMP15; /*!< Offset: 0x110 (R/W) Comparator Register 15 */ + uint32_t RESERVED31[1U]; + __IOM uint32_t FUNCTION15; /*!< Offset: 0x118 (R/W) Function Register 15 */ + uint32_t RESERVED32[934U]; + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R ) Lock Status Register */ + uint32_t RESERVED33[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) Device Architecture Register */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCDISS_Pos 23U /*!< DWT CTRL: CYCDISS Position */ +#define DWT_CTRL_CYCDISS_Msk (0x1UL << DWT_CTRL_CYCDISS_Pos) /*!< DWT CTRL: CYCDISS Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_ID_Pos 27U /*!< DWT FUNCTION: ID Position */ +#define DWT_FUNCTION_ID_Msk (0x1FUL << DWT_FUNCTION_ID_Pos) /*!< DWT FUNCTION: ID Mask */ + +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_ACTION_Pos 4U /*!< DWT FUNCTION: ACTION Position */ +#define DWT_FUNCTION_ACTION_Msk (0x1UL << DWT_FUNCTION_ACTION_Pos) /*!< DWT FUNCTION: ACTION Mask */ + +#define DWT_FUNCTION_MATCH_Pos 0U /*!< DWT FUNCTION: MATCH Position */ +#define DWT_FUNCTION_MATCH_Msk (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/) /*!< DWT FUNCTION: MATCH Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IOM uint32_t PSCR; /*!< Offset: 0x308 (R/W) Periodic Synchronization Control Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER Register */ + __IM uint32_t ITFTTD0; /*!< Offset: 0xEEC (R/ ) Integration Test FIFO Test Data 0 Register */ + __IOM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/W) Integration Test ATB Control Register 2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) Integration Test ATB Control Register 0 */ + __IM uint32_t ITFTTD1; /*!< Offset: 0xEFC (R/ ) Integration Test FIFO Test Data 1 Register */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) Device Configuration Register */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) Device Type Identifier Register */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_FOnMan_Pos 6U /*!< TPI FFCR: FOnMan Position */ +#define TPI_FFCR_FOnMan_Msk (0x1UL << TPI_FFCR_FOnMan_Pos) /*!< TPI FFCR: FOnMan Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration Test FIFO Test Data 0 Register Definitions */ +#define TPI_ITFTTD0_ATB_IF2_ATVALID_Pos 29U /*!< TPI ITFTTD0: ATB Interface 2 ATVALIDPosition */ +#define TPI_ITFTTD0_ATB_IF2_ATVALID_Msk (0x3UL << TPI_ITFTTD0_ATB_IF2_ATVALID_Pos) /*!< TPI ITFTTD0: ATB Interface 2 ATVALID Mask */ + +#define TPI_ITFTTD0_ATB_IF2_bytecount_Pos 27U /*!< TPI ITFTTD0: ATB Interface 2 byte count Position */ +#define TPI_ITFTTD0_ATB_IF2_bytecount_Msk (0x3UL << TPI_ITFTTD0_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 2 byte count Mask */ + +#define TPI_ITFTTD0_ATB_IF1_ATVALID_Pos 26U /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Position */ +#define TPI_ITFTTD0_ATB_IF1_ATVALID_Msk (0x3UL << TPI_ITFTTD0_ATB_IF1_ATVALID_Pos) /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Mask */ + +#define TPI_ITFTTD0_ATB_IF1_bytecount_Pos 24U /*!< TPI ITFTTD0: ATB Interface 1 byte count Position */ +#define TPI_ITFTTD0_ATB_IF1_bytecount_Msk (0x3UL << TPI_ITFTTD0_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 1 byte countt Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data2_Pos 16U /*!< TPI ITFTTD0: ATB Interface 1 data2 Position */ +#define TPI_ITFTTD0_ATB_IF1_data2_Msk (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos) /*!< TPI ITFTTD0: ATB Interface 1 data2 Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data1_Pos 8U /*!< TPI ITFTTD0: ATB Interface 1 data1 Position */ +#define TPI_ITFTTD0_ATB_IF1_data1_Msk (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos) /*!< TPI ITFTTD0: ATB Interface 1 data1 Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data0_Pos 0U /*!< TPI ITFTTD0: ATB Interface 1 data0 Position */ +#define TPI_ITFTTD0_ATB_IF1_data0_Msk (0xFFUL /*<< TPI_ITFTTD0_ATB_IF1_data0_Pos*/) /*!< TPI ITFTTD0: ATB Interface 1 data0 Mask */ + +/* TPI Integration Test ATB Control Register 2 Register Definitions */ +#define TPI_ITATBCTR2_AFVALID2S_Pos 1U /*!< TPI ITATBCTR2: AFVALID2S Position */ +#define TPI_ITATBCTR2_AFVALID2S_Msk (0x1UL << TPI_ITATBCTR2_AFVALID2S_Pos) /*!< TPI ITATBCTR2: AFVALID2SS Mask */ + +#define TPI_ITATBCTR2_AFVALID1S_Pos 1U /*!< TPI ITATBCTR2: AFVALID1S Position */ +#define TPI_ITATBCTR2_AFVALID1S_Msk (0x1UL << TPI_ITATBCTR2_AFVALID1S_Pos) /*!< TPI ITATBCTR2: AFVALID1SS Mask */ + +#define TPI_ITATBCTR2_ATREADY2S_Pos 0U /*!< TPI ITATBCTR2: ATREADY2S Position */ +#define TPI_ITATBCTR2_ATREADY2S_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY2S_Pos*/) /*!< TPI ITATBCTR2: ATREADY2S Mask */ + +#define TPI_ITATBCTR2_ATREADY1S_Pos 0U /*!< TPI ITATBCTR2: ATREADY1S Position */ +#define TPI_ITATBCTR2_ATREADY1S_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY1S_Pos*/) /*!< TPI ITATBCTR2: ATREADY1S Mask */ + +/* TPI Integration Test FIFO Test Data 1 Register Definitions */ +#define TPI_ITFTTD1_ATB_IF2_ATVALID_Pos 29U /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Position */ +#define TPI_ITFTTD1_ATB_IF2_ATVALID_Msk (0x3UL << TPI_ITFTTD1_ATB_IF2_ATVALID_Pos) /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Mask */ + +#define TPI_ITFTTD1_ATB_IF2_bytecount_Pos 27U /*!< TPI ITFTTD1: ATB Interface 2 byte count Position */ +#define TPI_ITFTTD1_ATB_IF2_bytecount_Msk (0x3UL << TPI_ITFTTD1_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 2 byte count Mask */ + +#define TPI_ITFTTD1_ATB_IF1_ATVALID_Pos 26U /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Position */ +#define TPI_ITFTTD1_ATB_IF1_ATVALID_Msk (0x3UL << TPI_ITFTTD1_ATB_IF1_ATVALID_Pos) /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Mask */ + +#define TPI_ITFTTD1_ATB_IF1_bytecount_Pos 24U /*!< TPI ITFTTD1: ATB Interface 1 byte count Position */ +#define TPI_ITFTTD1_ATB_IF1_bytecount_Msk (0x3UL << TPI_ITFTTD1_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 1 byte countt Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data2_Pos 16U /*!< TPI ITFTTD1: ATB Interface 2 data2 Position */ +#define TPI_ITFTTD1_ATB_IF2_data2_Msk (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos) /*!< TPI ITFTTD1: ATB Interface 2 data2 Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data1_Pos 8U /*!< TPI ITFTTD1: ATB Interface 2 data1 Position */ +#define TPI_ITFTTD1_ATB_IF2_data1_Msk (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos) /*!< TPI ITFTTD1: ATB Interface 2 data1 Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data0_Pos 0U /*!< TPI ITFTTD1: ATB Interface 2 data0 Position */ +#define TPI_ITFTTD1_ATB_IF2_data0_Msk (0xFFUL /*<< TPI_ITFTTD1_ATB_IF2_data0_Pos*/) /*!< TPI ITFTTD1: ATB Interface 2 data0 Mask */ + +/* TPI Integration Test ATB Control Register 0 Definitions */ +#define TPI_ITATBCTR0_AFVALID2S_Pos 1U /*!< TPI ITATBCTR0: AFVALID2S Position */ +#define TPI_ITATBCTR0_AFVALID2S_Msk (0x1UL << TPI_ITATBCTR0_AFVALID2S_Pos) /*!< TPI ITATBCTR0: AFVALID2SS Mask */ + +#define TPI_ITATBCTR0_AFVALID1S_Pos 1U /*!< TPI ITATBCTR0: AFVALID1S Position */ +#define TPI_ITATBCTR0_AFVALID1S_Msk (0x1UL << TPI_ITATBCTR0_AFVALID1S_Pos) /*!< TPI ITATBCTR0: AFVALID1SS Mask */ + +#define TPI_ITATBCTR0_ATREADY2S_Pos 0U /*!< TPI ITATBCTR0: ATREADY2S Position */ +#define TPI_ITATBCTR0_ATREADY2S_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY2S_Pos*/) /*!< TPI ITATBCTR0: ATREADY2S Mask */ + +#define TPI_ITATBCTR0_ATREADY1S_Pos 0U /*!< TPI ITATBCTR0: ATREADY1S Position */ +#define TPI_ITATBCTR0_ATREADY1S_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY1S_Pos*/) /*!< TPI ITATBCTR0: ATREADY1S Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_FIFOSZ_Pos 6U /*!< TPI DEVID: FIFOSZ Position */ +#define TPI_DEVID_FIFOSZ_Msk (0x7UL << TPI_DEVID_FIFOSZ_Pos) /*!< TPI DEVID: FIFOSZ Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x3FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) MPU Region Limit Address Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Region Base Address Register Alias 1 */ + __IOM uint32_t RLAR_A1; /*!< Offset: 0x018 (R/W) MPU Region Limit Address Register Alias 1 */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Region Base Address Register Alias 2 */ + __IOM uint32_t RLAR_A2; /*!< Offset: 0x020 (R/W) MPU Region Limit Address Register Alias 2 */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Region Base Address Register Alias 3 */ + __IOM uint32_t RLAR_A3; /*!< Offset: 0x028 (R/W) MPU Region Limit Address Register Alias 3 */ + uint32_t RESERVED0[1]; + union { + __IOM uint32_t MAIR[2]; + struct { + __IOM uint32_t MAIR0; /*!< Offset: 0x030 (R/W) MPU Memory Attribute Indirection Register 0 */ + __IOM uint32_t MAIR1; /*!< Offset: 0x034 (R/W) MPU Memory Attribute Indirection Register 1 */ + }; + }; +} MPU_Type; + +#define MPU_TYPE_RALIASES 4U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_BASE_Pos 5U /*!< MPU RBAR: BASE Position */ +#define MPU_RBAR_BASE_Msk (0x7FFFFFFUL << MPU_RBAR_BASE_Pos) /*!< MPU RBAR: BASE Mask */ + +#define MPU_RBAR_SH_Pos 3U /*!< MPU RBAR: SH Position */ +#define MPU_RBAR_SH_Msk (0x3UL << MPU_RBAR_SH_Pos) /*!< MPU RBAR: SH Mask */ + +#define MPU_RBAR_AP_Pos 1U /*!< MPU RBAR: AP Position */ +#define MPU_RBAR_AP_Msk (0x3UL << MPU_RBAR_AP_Pos) /*!< MPU RBAR: AP Mask */ + +#define MPU_RBAR_XN_Pos 0U /*!< MPU RBAR: XN Position */ +#define MPU_RBAR_XN_Msk (01UL /*<< MPU_RBAR_XN_Pos*/) /*!< MPU RBAR: XN Mask */ + +/* MPU Region Limit Address Register Definitions */ +#define MPU_RLAR_LIMIT_Pos 5U /*!< MPU RLAR: LIMIT Position */ +#define MPU_RLAR_LIMIT_Msk (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos) /*!< MPU RLAR: LIMIT Mask */ + +#define MPU_RLAR_AttrIndx_Pos 1U /*!< MPU RLAR: AttrIndx Position */ +#define MPU_RLAR_AttrIndx_Msk (0x7UL << MPU_RLAR_AttrIndx_Pos) /*!< MPU RLAR: AttrIndx Mask */ + +#define MPU_RLAR_EN_Pos 0U /*!< MPU RLAR: Region enable bit Position */ +#define MPU_RLAR_EN_Msk (1UL /*<< MPU_RLAR_EN_Pos*/) /*!< MPU RLAR: Region enable bit Disable Mask */ + +/* MPU Memory Attribute Indirection Register 0 Definitions */ +#define MPU_MAIR0_Attr3_Pos 24U /*!< MPU MAIR0: Attr3 Position */ +#define MPU_MAIR0_Attr3_Msk (0xFFUL << MPU_MAIR0_Attr3_Pos) /*!< MPU MAIR0: Attr3 Mask */ + +#define MPU_MAIR0_Attr2_Pos 16U /*!< MPU MAIR0: Attr2 Position */ +#define MPU_MAIR0_Attr2_Msk (0xFFUL << MPU_MAIR0_Attr2_Pos) /*!< MPU MAIR0: Attr2 Mask */ + +#define MPU_MAIR0_Attr1_Pos 8U /*!< MPU MAIR0: Attr1 Position */ +#define MPU_MAIR0_Attr1_Msk (0xFFUL << MPU_MAIR0_Attr1_Pos) /*!< MPU MAIR0: Attr1 Mask */ + +#define MPU_MAIR0_Attr0_Pos 0U /*!< MPU MAIR0: Attr0 Position */ +#define MPU_MAIR0_Attr0_Msk (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/) /*!< MPU MAIR0: Attr0 Mask */ + +/* MPU Memory Attribute Indirection Register 1 Definitions */ +#define MPU_MAIR1_Attr7_Pos 24U /*!< MPU MAIR1: Attr7 Position */ +#define MPU_MAIR1_Attr7_Msk (0xFFUL << MPU_MAIR1_Attr7_Pos) /*!< MPU MAIR1: Attr7 Mask */ + +#define MPU_MAIR1_Attr6_Pos 16U /*!< MPU MAIR1: Attr6 Position */ +#define MPU_MAIR1_Attr6_Msk (0xFFUL << MPU_MAIR1_Attr6_Pos) /*!< MPU MAIR1: Attr6 Mask */ + +#define MPU_MAIR1_Attr5_Pos 8U /*!< MPU MAIR1: Attr5 Position */ +#define MPU_MAIR1_Attr5_Msk (0xFFUL << MPU_MAIR1_Attr5_Pos) /*!< MPU MAIR1: Attr5 Mask */ + +#define MPU_MAIR1_Attr4_Pos 0U /*!< MPU MAIR1: Attr4 Position */ +#define MPU_MAIR1_Attr4_Msk (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/) /*!< MPU MAIR1: Attr4 Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SAU Security Attribution Unit (SAU) + \brief Type definitions for the Security Attribution Unit (SAU) + @{ + */ + +/** + \brief Structure type to access the Security Attribution Unit (SAU). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SAU Control Register */ + __IM uint32_t TYPE; /*!< Offset: 0x004 (R/ ) SAU Type Register */ +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) SAU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) SAU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) SAU Region Limit Address Register */ +#else + uint32_t RESERVED0[3]; +#endif + __IOM uint32_t SFSR; /*!< Offset: 0x014 (R/W) Secure Fault Status Register */ + __IOM uint32_t SFAR; /*!< Offset: 0x018 (R/W) Secure Fault Address Register */ +} SAU_Type; + +/* SAU Control Register Definitions */ +#define SAU_CTRL_ALLNS_Pos 1U /*!< SAU CTRL: ALLNS Position */ +#define SAU_CTRL_ALLNS_Msk (1UL << SAU_CTRL_ALLNS_Pos) /*!< SAU CTRL: ALLNS Mask */ + +#define SAU_CTRL_ENABLE_Pos 0U /*!< SAU CTRL: ENABLE Position */ +#define SAU_CTRL_ENABLE_Msk (1UL /*<< SAU_CTRL_ENABLE_Pos*/) /*!< SAU CTRL: ENABLE Mask */ + +/* SAU Type Register Definitions */ +#define SAU_TYPE_SREGION_Pos 0U /*!< SAU TYPE: SREGION Position */ +#define SAU_TYPE_SREGION_Msk (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/) /*!< SAU TYPE: SREGION Mask */ + +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) +/* SAU Region Number Register Definitions */ +#define SAU_RNR_REGION_Pos 0U /*!< SAU RNR: REGION Position */ +#define SAU_RNR_REGION_Msk (0xFFUL /*<< SAU_RNR_REGION_Pos*/) /*!< SAU RNR: REGION Mask */ + +/* SAU Region Base Address Register Definitions */ +#define SAU_RBAR_BADDR_Pos 5U /*!< SAU RBAR: BADDR Position */ +#define SAU_RBAR_BADDR_Msk (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos) /*!< SAU RBAR: BADDR Mask */ + +/* SAU Region Limit Address Register Definitions */ +#define SAU_RLAR_LADDR_Pos 5U /*!< SAU RLAR: LADDR Position */ +#define SAU_RLAR_LADDR_Msk (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos) /*!< SAU RLAR: LADDR Mask */ + +#define SAU_RLAR_NSC_Pos 1U /*!< SAU RLAR: NSC Position */ +#define SAU_RLAR_NSC_Msk (1UL << SAU_RLAR_NSC_Pos) /*!< SAU RLAR: NSC Mask */ + +#define SAU_RLAR_ENABLE_Pos 0U /*!< SAU RLAR: ENABLE Position */ +#define SAU_RLAR_ENABLE_Msk (1UL /*<< SAU_RLAR_ENABLE_Pos*/) /*!< SAU RLAR: ENABLE Mask */ + +#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */ + +/* Secure Fault Status Register Definitions */ +#define SAU_SFSR_LSERR_Pos 7U /*!< SAU SFSR: LSERR Position */ +#define SAU_SFSR_LSERR_Msk (1UL << SAU_SFSR_LSERR_Pos) /*!< SAU SFSR: LSERR Mask */ + +#define SAU_SFSR_SFARVALID_Pos 6U /*!< SAU SFSR: SFARVALID Position */ +#define SAU_SFSR_SFARVALID_Msk (1UL << SAU_SFSR_SFARVALID_Pos) /*!< SAU SFSR: SFARVALID Mask */ + +#define SAU_SFSR_LSPERR_Pos 5U /*!< SAU SFSR: LSPERR Position */ +#define SAU_SFSR_LSPERR_Msk (1UL << SAU_SFSR_LSPERR_Pos) /*!< SAU SFSR: LSPERR Mask */ + +#define SAU_SFSR_INVTRAN_Pos 4U /*!< SAU SFSR: INVTRAN Position */ +#define SAU_SFSR_INVTRAN_Msk (1UL << SAU_SFSR_INVTRAN_Pos) /*!< SAU SFSR: INVTRAN Mask */ + +#define SAU_SFSR_AUVIOL_Pos 3U /*!< SAU SFSR: AUVIOL Position */ +#define SAU_SFSR_AUVIOL_Msk (1UL << SAU_SFSR_AUVIOL_Pos) /*!< SAU SFSR: AUVIOL Mask */ + +#define SAU_SFSR_INVER_Pos 2U /*!< SAU SFSR: INVER Position */ +#define SAU_SFSR_INVER_Msk (1UL << SAU_SFSR_INVER_Pos) /*!< SAU SFSR: INVER Mask */ + +#define SAU_SFSR_INVIS_Pos 1U /*!< SAU SFSR: INVIS Position */ +#define SAU_SFSR_INVIS_Msk (1UL << SAU_SFSR_INVIS_Pos) /*!< SAU SFSR: INVIS Mask */ + +#define SAU_SFSR_INVEP_Pos 0U /*!< SAU SFSR: INVEP Position */ +#define SAU_SFSR_INVEP_Msk (1UL /*<< SAU_SFSR_INVEP_Pos*/) /*!< SAU SFSR: INVEP Mask */ + +/*@} end of group CMSIS_SAU */ +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_FPU Floating Point Unit (FPU) + \brief Type definitions for the Floating Point Unit (FPU) + @{ + */ + +/** + \brief Structure type to access the Floating Point Unit (FPU). + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IOM uint32_t FPCCR; /*!< Offset: 0x004 (R/W) Floating-Point Context Control Register */ + __IOM uint32_t FPCAR; /*!< Offset: 0x008 (R/W) Floating-Point Context Address Register */ + __IOM uint32_t FPDSCR; /*!< Offset: 0x00C (R/W) Floating-Point Default Status Control Register */ + __IM uint32_t MVFR0; /*!< Offset: 0x010 (R/ ) Media and FP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x014 (R/ ) Media and FP Feature Register 1 */ +} FPU_Type; + +/* Floating-Point Context Control Register Definitions */ +#define FPU_FPCCR_ASPEN_Pos 31U /*!< FPCCR: ASPEN bit Position */ +#define FPU_FPCCR_ASPEN_Msk (1UL << FPU_FPCCR_ASPEN_Pos) /*!< FPCCR: ASPEN bit Mask */ + +#define FPU_FPCCR_LSPEN_Pos 30U /*!< FPCCR: LSPEN Position */ +#define FPU_FPCCR_LSPEN_Msk (1UL << FPU_FPCCR_LSPEN_Pos) /*!< FPCCR: LSPEN bit Mask */ + +#define FPU_FPCCR_LSPENS_Pos 29U /*!< FPCCR: LSPENS Position */ +#define FPU_FPCCR_LSPENS_Msk (1UL << FPU_FPCCR_LSPENS_Pos) /*!< FPCCR: LSPENS bit Mask */ + +#define FPU_FPCCR_CLRONRET_Pos 28U /*!< FPCCR: CLRONRET Position */ +#define FPU_FPCCR_CLRONRET_Msk (1UL << FPU_FPCCR_CLRONRET_Pos) /*!< FPCCR: CLRONRET bit Mask */ + +#define FPU_FPCCR_CLRONRETS_Pos 27U /*!< FPCCR: CLRONRETS Position */ +#define FPU_FPCCR_CLRONRETS_Msk (1UL << FPU_FPCCR_CLRONRETS_Pos) /*!< FPCCR: CLRONRETS bit Mask */ + +#define FPU_FPCCR_TS_Pos 26U /*!< FPCCR: TS Position */ +#define FPU_FPCCR_TS_Msk (1UL << FPU_FPCCR_TS_Pos) /*!< FPCCR: TS bit Mask */ + +#define FPU_FPCCR_UFRDY_Pos 10U /*!< FPCCR: UFRDY Position */ +#define FPU_FPCCR_UFRDY_Msk (1UL << FPU_FPCCR_UFRDY_Pos) /*!< FPCCR: UFRDY bit Mask */ + +#define FPU_FPCCR_SPLIMVIOL_Pos 9U /*!< FPCCR: SPLIMVIOL Position */ +#define FPU_FPCCR_SPLIMVIOL_Msk (1UL << FPU_FPCCR_SPLIMVIOL_Pos) /*!< FPCCR: SPLIMVIOL bit Mask */ + +#define FPU_FPCCR_MONRDY_Pos 8U /*!< FPCCR: MONRDY Position */ +#define FPU_FPCCR_MONRDY_Msk (1UL << FPU_FPCCR_MONRDY_Pos) /*!< FPCCR: MONRDY bit Mask */ + +#define FPU_FPCCR_SFRDY_Pos 7U /*!< FPCCR: SFRDY Position */ +#define FPU_FPCCR_SFRDY_Msk (1UL << FPU_FPCCR_SFRDY_Pos) /*!< FPCCR: SFRDY bit Mask */ + +#define FPU_FPCCR_BFRDY_Pos 6U /*!< FPCCR: BFRDY Position */ +#define FPU_FPCCR_BFRDY_Msk (1UL << FPU_FPCCR_BFRDY_Pos) /*!< FPCCR: BFRDY bit Mask */ + +#define FPU_FPCCR_MMRDY_Pos 5U /*!< FPCCR: MMRDY Position */ +#define FPU_FPCCR_MMRDY_Msk (1UL << FPU_FPCCR_MMRDY_Pos) /*!< FPCCR: MMRDY bit Mask */ + +#define FPU_FPCCR_HFRDY_Pos 4U /*!< FPCCR: HFRDY Position */ +#define FPU_FPCCR_HFRDY_Msk (1UL << FPU_FPCCR_HFRDY_Pos) /*!< FPCCR: HFRDY bit Mask */ + +#define FPU_FPCCR_THREAD_Pos 3U /*!< FPCCR: processor mode bit Position */ +#define FPU_FPCCR_THREAD_Msk (1UL << FPU_FPCCR_THREAD_Pos) /*!< FPCCR: processor mode active bit Mask */ + +#define FPU_FPCCR_S_Pos 2U /*!< FPCCR: Security status of the FP context bit Position */ +#define FPU_FPCCR_S_Msk (1UL << FPU_FPCCR_S_Pos) /*!< FPCCR: Security status of the FP context bit Mask */ + +#define FPU_FPCCR_USER_Pos 1U /*!< FPCCR: privilege level bit Position */ +#define FPU_FPCCR_USER_Msk (1UL << FPU_FPCCR_USER_Pos) /*!< FPCCR: privilege level bit Mask */ + +#define FPU_FPCCR_LSPACT_Pos 0U /*!< FPCCR: Lazy state preservation active bit Position */ +#define FPU_FPCCR_LSPACT_Msk (1UL /*<< FPU_FPCCR_LSPACT_Pos*/) /*!< FPCCR: Lazy state preservation active bit Mask */ + +/* Floating-Point Context Address Register Definitions */ +#define FPU_FPCAR_ADDRESS_Pos 3U /*!< FPCAR: ADDRESS bit Position */ +#define FPU_FPCAR_ADDRESS_Msk (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos) /*!< FPCAR: ADDRESS bit Mask */ + +/* Floating-Point Default Status Control Register Definitions */ +#define FPU_FPDSCR_AHP_Pos 26U /*!< FPDSCR: AHP bit Position */ +#define FPU_FPDSCR_AHP_Msk (1UL << FPU_FPDSCR_AHP_Pos) /*!< FPDSCR: AHP bit Mask */ + +#define FPU_FPDSCR_DN_Pos 25U /*!< FPDSCR: DN bit Position */ +#define FPU_FPDSCR_DN_Msk (1UL << FPU_FPDSCR_DN_Pos) /*!< FPDSCR: DN bit Mask */ + +#define FPU_FPDSCR_FZ_Pos 24U /*!< FPDSCR: FZ bit Position */ +#define FPU_FPDSCR_FZ_Msk (1UL << FPU_FPDSCR_FZ_Pos) /*!< FPDSCR: FZ bit Mask */ + +#define FPU_FPDSCR_RMode_Pos 22U /*!< FPDSCR: RMode bit Position */ +#define FPU_FPDSCR_RMode_Msk (3UL << FPU_FPDSCR_RMode_Pos) /*!< FPDSCR: RMode bit Mask */ + +/* Media and FP Feature Register 0 Definitions */ +#define FPU_MVFR0_FP_rounding_modes_Pos 28U /*!< MVFR0: FP rounding modes bits Position */ +#define FPU_MVFR0_FP_rounding_modes_Msk (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos) /*!< MVFR0: FP rounding modes bits Mask */ + +#define FPU_MVFR0_Short_vectors_Pos 24U /*!< MVFR0: Short vectors bits Position */ +#define FPU_MVFR0_Short_vectors_Msk (0xFUL << FPU_MVFR0_Short_vectors_Pos) /*!< MVFR0: Short vectors bits Mask */ + +#define FPU_MVFR0_Square_root_Pos 20U /*!< MVFR0: Square root bits Position */ +#define FPU_MVFR0_Square_root_Msk (0xFUL << FPU_MVFR0_Square_root_Pos) /*!< MVFR0: Square root bits Mask */ + +#define FPU_MVFR0_Divide_Pos 16U /*!< MVFR0: Divide bits Position */ +#define FPU_MVFR0_Divide_Msk (0xFUL << FPU_MVFR0_Divide_Pos) /*!< MVFR0: Divide bits Mask */ + +#define FPU_MVFR0_FP_excep_trapping_Pos 12U /*!< MVFR0: FP exception trapping bits Position */ +#define FPU_MVFR0_FP_excep_trapping_Msk (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos) /*!< MVFR0: FP exception trapping bits Mask */ + +#define FPU_MVFR0_Double_precision_Pos 8U /*!< MVFR0: Double-precision bits Position */ +#define FPU_MVFR0_Double_precision_Msk (0xFUL << FPU_MVFR0_Double_precision_Pos) /*!< MVFR0: Double-precision bits Mask */ + +#define FPU_MVFR0_Single_precision_Pos 4U /*!< MVFR0: Single-precision bits Position */ +#define FPU_MVFR0_Single_precision_Msk (0xFUL << FPU_MVFR0_Single_precision_Pos) /*!< MVFR0: Single-precision bits Mask */ + +#define FPU_MVFR0_A_SIMD_registers_Pos 0U /*!< MVFR0: A_SIMD registers bits Position */ +#define FPU_MVFR0_A_SIMD_registers_Msk (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/) /*!< MVFR0: A_SIMD registers bits Mask */ + +/* Media and FP Feature Register 1 Definitions */ +#define FPU_MVFR1_FP_fused_MAC_Pos 28U /*!< MVFR1: FP fused MAC bits Position */ +#define FPU_MVFR1_FP_fused_MAC_Msk (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos) /*!< MVFR1: FP fused MAC bits Mask */ + +#define FPU_MVFR1_FP_HPFP_Pos 24U /*!< MVFR1: FP HPFP bits Position */ +#define FPU_MVFR1_FP_HPFP_Msk (0xFUL << FPU_MVFR1_FP_HPFP_Pos) /*!< MVFR1: FP HPFP bits Mask */ + +#define FPU_MVFR1_D_NaN_mode_Pos 4U /*!< MVFR1: D_NaN mode bits Position */ +#define FPU_MVFR1_D_NaN_mode_Msk (0xFUL << FPU_MVFR1_D_NaN_mode_Pos) /*!< MVFR1: D_NaN mode bits Mask */ + +#define FPU_MVFR1_FtZ_mode_Pos 0U /*!< MVFR1: FtZ mode bits Position */ +#define FPU_MVFR1_FtZ_mode_Msk (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/) /*!< MVFR1: FtZ mode bits Mask */ + +/*@} end of group CMSIS_FPU */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ + uint32_t RESERVED4[1U]; + __IOM uint32_t DAUTHCTRL; /*!< Offset: 0x014 (R/W) Debug Authentication Control Register */ + __IOM uint32_t DSCSR; /*!< Offset: 0x018 (R/W) Debug Security Control and Status Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESTART_ST_Pos 26U /*!< CoreDebug DHCSR: S_RESTART_ST Position */ +#define CoreDebug_DHCSR_S_RESTART_ST_Msk (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos) /*!< CoreDebug DHCSR: S_RESTART_ST Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/* Debug Authentication Control Register Definitions */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos 3U /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */ + +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos 2U /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos) /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */ + +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos 1U /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */ +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */ + +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos 0U /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */ + +/* Debug Security Control and Status Register Definitions */ +#define CoreDebug_DSCSR_CDS_Pos 16U /*!< CoreDebug DSCSR: CDS Position */ +#define CoreDebug_DSCSR_CDS_Msk (1UL << CoreDebug_DSCSR_CDS_Pos) /*!< CoreDebug DSCSR: CDS Mask */ + +#define CoreDebug_DSCSR_SBRSEL_Pos 1U /*!< CoreDebug DSCSR: SBRSEL Position */ +#define CoreDebug_DSCSR_SBRSEL_Msk (1UL << CoreDebug_DSCSR_SBRSEL_Pos) /*!< CoreDebug DSCSR: SBRSEL Mask */ + +#define CoreDebug_DSCSR_SBRSELEN_Pos 0U /*!< CoreDebug DSCSR: SBRSELEN Position */ +#define CoreDebug_DSCSR_SBRSELEN_Msk (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/) /*!< CoreDebug DSCSR: SBRSELEN Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ + #define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ + #define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ + #define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ + #define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ + #define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ + #define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ + #define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ + #define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + + #define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ + #define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ + #define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ + #define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + #define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ + #define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ + #define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ + #define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE ) /*!< Core Debug configuration struct */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ + #endif + + #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SAU_BASE (SCS_BASE + 0x0DD0UL) /*!< Security Attribution Unit */ + #define SAU ((SAU_Type *) SAU_BASE ) /*!< Security Attribution Unit */ + #endif + + #define FPU_BASE (SCS_BASE + 0x0F30UL) /*!< Floating Point Unit */ + #define FPU ((FPU_Type *) FPU_BASE ) /*!< Floating Point Unit */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SCS_BASE_NS (0xE002E000UL) /*!< System Control Space Base Address (non-secure address space) */ + #define CoreDebug_BASE_NS (0xE002EDF0UL) /*!< Core Debug Base Address (non-secure address space) */ + #define SysTick_BASE_NS (SCS_BASE_NS + 0x0010UL) /*!< SysTick Base Address (non-secure address space) */ + #define NVIC_BASE_NS (SCS_BASE_NS + 0x0100UL) /*!< NVIC Base Address (non-secure address space) */ + #define SCB_BASE_NS (SCS_BASE_NS + 0x0D00UL) /*!< System Control Block Base Address (non-secure address space) */ + + #define SCnSCB_NS ((SCnSCB_Type *) SCS_BASE_NS ) /*!< System control Register not in SCB(non-secure address space) */ + #define SCB_NS ((SCB_Type *) SCB_BASE_NS ) /*!< SCB configuration struct (non-secure address space) */ + #define SysTick_NS ((SysTick_Type *) SysTick_BASE_NS ) /*!< SysTick configuration struct (non-secure address space) */ + #define NVIC_NS ((NVIC_Type *) NVIC_BASE_NS ) /*!< NVIC configuration struct (non-secure address space) */ + #define CoreDebug_NS ((CoreDebug_Type *) CoreDebug_BASE_NS) /*!< Core Debug configuration struct (non-secure address space) */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE_NS (SCS_BASE_NS + 0x0D90UL) /*!< Memory Protection Unit (non-secure address space) */ + #define MPU_NS ((MPU_Type *) MPU_BASE_NS ) /*!< Memory Protection Unit (non-secure address space) */ + #endif + + #define FPU_BASE_NS (SCS_BASE_NS + 0x0F30UL) /*!< Floating Point Unit (non-secure address space) */ + #define FPU_NS ((FPU_Type *) FPU_BASE_NS ) /*!< Floating Point Unit (non-secure address space) */ + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* Special LR values for Secure/Non-Secure call handling and exception handling */ + +/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS */ +#define FNC_RETURN (0xFEFFFFFFUL) /* bit [0] ignored when processing a branch */ + +/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */ +#define EXC_RETURN_PREFIX (0xFF000000UL) /* bits [31:24] set to indicate an EXC_RETURN value */ +#define EXC_RETURN_S (0x00000040UL) /* bit [6] stack used to push registers: 0=Non-secure 1=Secure */ +#define EXC_RETURN_DCRS (0x00000020UL) /* bit [5] stacking rules for called registers: 0=skipped 1=saved */ +#define EXC_RETURN_FTYPE (0x00000010UL) /* bit [4] allocate stack for floating-point context: 0=done 1=skipped */ +#define EXC_RETURN_MODE (0x00000008UL) /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode */ +#define EXC_RETURN_SPSEL (0x00000004UL) /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP */ +#define EXC_RETURN_ES (0x00000001UL) /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */ + +/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking */ +#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) /* Value for processors with floating-point extension: */ +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125AUL) /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE */ +#else +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125BUL) /* Value for processors without floating-point extension */ +#endif + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Get Interrupt Target State + \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + \return 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Target State + \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |= ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Clear Interrupt Target State + \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + __DSB(); +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Set Priority Grouping (non-secure) + \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB_NS->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB_NS->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping (non-secure) + \details Reads the priority grouping field from the non-secure NVIC when in secure state. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void) +{ + return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt (non-secure) + \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Interrupt Enable status (non-secure) + \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt (non-secure) + \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Pending Interrupt (non-secure) + \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt (non-secure) + \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt (non-secure) + \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt (non-secure) + \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority (non-secure) + \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every non-secure processor exception. + */ +__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority (non-secure) + \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv8.h" + +#endif + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + uint32_t mvfr0; + + mvfr0 = FPU->MVFR0; + if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U) + { + return 2U; /* Double + Single precision FPU */ + } + else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U) + { + return 1U; /* Single precision FPU */ + } + else + { + return 0U; /* No FPU */ + } +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ########################## SAU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SAUFunctions SAU Functions + \brief Functions that configure the SAU. + @{ + */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + +/** + \brief Enable SAU + \details Enables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Enable(void) +{ + SAU->CTRL |= (SAU_CTRL_ENABLE_Msk); +} + + + +/** + \brief Disable SAU + \details Disables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Disable(void) +{ + SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk); +} + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_SAUFunctions */ + + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief System Tick Configuration (non-secure) + \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function TZ_SysTick_Config_NS is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick_NS->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick_NS->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick_NS->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM33_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm35p.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm35p.h new file mode 100644 index 0000000000..5579c82306 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm35p.h @@ -0,0 +1,2910 @@ +/**************************************************************************//** + * @file core_cm35p.h + * @brief CMSIS Cortex-M35P Core Peripheral Access Layer Header File + * @version V1.0.0 + * @date 12. November 2018 + ******************************************************************************/ +/* + * Copyright (c) 2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM35P_H_GENERIC +#define __CORE_CM35P_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M35P + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM35P definitions */ +#define __CM35P_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM35P_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM35P_CMSIS_VERSION ((__CM35P_CMSIS_VERSION_MAIN << 16U) | \ + __CM35P_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (35U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions. +*/ +#if defined ( __CC_ARM ) + #if defined (__TARGET_FPU_VFP) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined (__ARM_FP) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __ICCARM__ ) + #if defined (__ARMVFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + + #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U) + #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U) + #define __DSP_USED 1U + #else + #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)" + #define __DSP_USED 0U + #endif + #else + #define __DSP_USED 0U + #endif + +#elif defined ( __TI_ARM__ ) + #if defined (__TI_VFP_SUPPORT__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TASKING__ ) + #if defined (__FPU_VFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM35P_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM35P_H_DEPENDANT +#define __CORE_CM35P_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM35P_REV + #define __CM35P_REV 0x0000U + #warning "__CM35P_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __SAUREGION_PRESENT + #define __SAUREGION_PRESENT 0U + #warning "__SAUREGION_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __DSP_PRESENT + #define __DSP_PRESENT 0U + #warning "__DSP_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M35P */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core SAU Register + - Core FPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + +#define APSR_GE_Pos 16U /*!< APSR: GE Position */ +#define APSR_GE_Msk (0xFUL << APSR_GE_Pos) /*!< APSR: GE Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:7; /*!< bit: 9..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t IT:2; /*!< bit: 25..26 saved IT state (read 0) */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_IT_Pos 25U /*!< xPSR: IT Position */ +#define xPSR_IT_Msk (3UL << xPSR_IT_Pos) /*!< xPSR: IT Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_GE_Pos 16U /*!< xPSR: GE Position */ +#define xPSR_GE_Msk (0xFUL << xPSR_GE_Pos) /*!< xPSR: GE Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack-pointer select */ + uint32_t FPCA:1; /*!< bit: 2 Floating-point context active */ + uint32_t SFPA:1; /*!< bit: 3 Secure floating-point active */ + uint32_t _reserved1:28; /*!< bit: 4..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SFPA_Pos 3U /*!< CONTROL: SFPA Position */ +#define CONTROL_SFPA_Msk (1UL << CONTROL_SFPA_Pos) /*!< CONTROL: SFPA Mask */ + +#define CONTROL_FPCA_Pos 2U /*!< CONTROL: FPCA Position */ +#define CONTROL_FPCA_Msk (1UL << CONTROL_FPCA_Pos) /*!< CONTROL: FPCA Mask */ + +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[16U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[16U]; + __IOM uint32_t ICER[16U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[16U]; + __IOM uint32_t ISPR[16U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[16U]; + __IOM uint32_t ICPR[16U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[16U]; + __IOM uint32_t IABR[16U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[16U]; + __IOM uint32_t ITNS[16U]; /*!< Offset: 0x280 (R/W) Interrupt Non-Secure State Register */ + uint32_t RESERVED5[16U]; + __IOM uint8_t IPR[496U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED6[580U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHPR[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t ID_PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t ID_DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ID_ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t ID_MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ID_ISAR[6U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + __IM uint32_t CLIDR; /*!< Offset: 0x078 (R/ ) Cache Level ID register */ + __IM uint32_t CTR; /*!< Offset: 0x07C (R/ ) Cache Type register */ + __IM uint32_t CCSIDR; /*!< Offset: 0x080 (R/ ) Cache Size ID Register */ + __IOM uint32_t CSSELR; /*!< Offset: 0x084 (R/W) Cache Size Selection Register */ + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ + __IOM uint32_t NSACR; /*!< Offset: 0x08C (R/W) Non-Secure Access Control Register */ + uint32_t RESERVED3[92U]; + __OM uint32_t STIR; /*!< Offset: 0x200 ( /W) Software Triggered Interrupt Register */ + uint32_t RESERVED4[15U]; + __IM uint32_t MVFR0; /*!< Offset: 0x240 (R/ ) Media and VFP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x244 (R/ ) Media and VFP Feature Register 1 */ + __IM uint32_t MVFR2; /*!< Offset: 0x248 (R/ ) Media and VFP Feature Register 2 */ + uint32_t RESERVED5[1U]; + __OM uint32_t ICIALLU; /*!< Offset: 0x250 ( /W) I-Cache Invalidate All to PoU */ + uint32_t RESERVED6[1U]; + __OM uint32_t ICIMVAU; /*!< Offset: 0x258 ( /W) I-Cache Invalidate by MVA to PoU */ + __OM uint32_t DCIMVAC; /*!< Offset: 0x25C ( /W) D-Cache Invalidate by MVA to PoC */ + __OM uint32_t DCISW; /*!< Offset: 0x260 ( /W) D-Cache Invalidate by Set-way */ + __OM uint32_t DCCMVAU; /*!< Offset: 0x264 ( /W) D-Cache Clean by MVA to PoU */ + __OM uint32_t DCCMVAC; /*!< Offset: 0x268 ( /W) D-Cache Clean by MVA to PoC */ + __OM uint32_t DCCSW; /*!< Offset: 0x26C ( /W) D-Cache Clean by Set-way */ + __OM uint32_t DCCIMVAC; /*!< Offset: 0x270 ( /W) D-Cache Clean and Invalidate by MVA to PoC */ + __OM uint32_t DCCISW; /*!< Offset: 0x274 ( /W) D-Cache Clean and Invalidate by Set-way */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_PENDNMISET_Pos 31U /*!< SCB ICSR: PENDNMISET Position */ +#define SCB_ICSR_PENDNMISET_Msk (1UL << SCB_ICSR_PENDNMISET_Pos) /*!< SCB ICSR: PENDNMISET Mask */ + +#define SCB_ICSR_NMIPENDSET_Pos SCB_ICSR_PENDNMISET_Pos /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */ +#define SCB_ICSR_NMIPENDSET_Msk SCB_ICSR_PENDNMISET_Msk /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */ + +#define SCB_ICSR_PENDNMICLR_Pos 30U /*!< SCB ICSR: PENDNMICLR Position */ +#define SCB_ICSR_PENDNMICLR_Msk (1UL << SCB_ICSR_PENDNMICLR_Pos) /*!< SCB ICSR: PENDNMICLR Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_STTNS_Pos 24U /*!< SCB ICSR: STTNS Position (Security Extension) */ +#define SCB_ICSR_STTNS_Msk (1UL << SCB_ICSR_STTNS_Pos) /*!< SCB ICSR: STTNS Mask (Security Extension) */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIS_Pos 14U /*!< SCB AIRCR: PRIS Position */ +#define SCB_AIRCR_PRIS_Msk (1UL << SCB_AIRCR_PRIS_Pos) /*!< SCB AIRCR: PRIS Mask */ + +#define SCB_AIRCR_BFHFNMINS_Pos 13U /*!< SCB AIRCR: BFHFNMINS Position */ +#define SCB_AIRCR_BFHFNMINS_Msk (1UL << SCB_AIRCR_BFHFNMINS_Pos) /*!< SCB AIRCR: BFHFNMINS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQS_Pos 3U /*!< SCB AIRCR: SYSRESETREQS Position */ +#define SCB_AIRCR_SYSRESETREQS_Msk (1UL << SCB_AIRCR_SYSRESETREQS_Pos) /*!< SCB AIRCR: SYSRESETREQS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEPS_Pos 3U /*!< SCB SCR: SLEEPDEEPS Position */ +#define SCB_SCR_SLEEPDEEPS_Msk (1UL << SCB_SCR_SLEEPDEEPS_Pos) /*!< SCB SCR: SLEEPDEEPS Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_BP_Pos 18U /*!< SCB CCR: BP Position */ +#define SCB_CCR_BP_Msk (1UL << SCB_CCR_BP_Pos) /*!< SCB CCR: BP Mask */ + +#define SCB_CCR_IC_Pos 17U /*!< SCB CCR: IC Position */ +#define SCB_CCR_IC_Msk (1UL << SCB_CCR_IC_Pos) /*!< SCB CCR: IC Mask */ + +#define SCB_CCR_DC_Pos 16U /*!< SCB CCR: DC Position */ +#define SCB_CCR_DC_Msk (1UL << SCB_CCR_DC_Pos) /*!< SCB CCR: DC Mask */ + +#define SCB_CCR_STKOFHFNMIGN_Pos 10U /*!< SCB CCR: STKOFHFNMIGN Position */ +#define SCB_CCR_STKOFHFNMIGN_Msk (1UL << SCB_CCR_STKOFHFNMIGN_Pos) /*!< SCB CCR: STKOFHFNMIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_HARDFAULTPENDED_Pos 21U /*!< SCB SHCSR: HARDFAULTPENDED Position */ +#define SCB_SHCSR_HARDFAULTPENDED_Msk (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos) /*!< SCB SHCSR: HARDFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTPENDED_Pos 20U /*!< SCB SHCSR: SECUREFAULTPENDED Position */ +#define SCB_SHCSR_SECUREFAULTPENDED_Msk (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos) /*!< SCB SHCSR: SECUREFAULTPENDED Mask */ + +#define SCB_SHCSR_SECUREFAULTENA_Pos 19U /*!< SCB SHCSR: SECUREFAULTENA Position */ +#define SCB_SHCSR_SECUREFAULTENA_Msk (1UL << SCB_SHCSR_SECUREFAULTENA_Pos) /*!< SCB SHCSR: SECUREFAULTENA Mask */ + +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_NMIACT_Pos 5U /*!< SCB SHCSR: NMIACT Position */ +#define SCB_SHCSR_NMIACT_Msk (1UL << SCB_SHCSR_NMIACT_Pos) /*!< SCB SHCSR: NMIACT Mask */ + +#define SCB_SHCSR_SECUREFAULTACT_Pos 4U /*!< SCB SHCSR: SECUREFAULTACT Position */ +#define SCB_SHCSR_SECUREFAULTACT_Msk (1UL << SCB_SHCSR_SECUREFAULTACT_Pos) /*!< SCB SHCSR: SECUREFAULTACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_HARDFAULTACT_Pos 2U /*!< SCB SHCSR: HARDFAULTACT Position */ +#define SCB_SHCSR_HARDFAULTACT_Msk (1UL << SCB_SHCSR_HARDFAULTACT_Pos) /*!< SCB SHCSR: HARDFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MLSPERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 5U) /*!< SCB CFSR (MMFSR): MLSPERR Position */ +#define SCB_CFSR_MLSPERR_Msk (1UL << SCB_CFSR_MLSPERR_Pos) /*!< SCB CFSR (MMFSR): MLSPERR Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_LSPERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 5U) /*!< SCB CFSR (BFSR): LSPERR Position */ +#define SCB_CFSR_LSPERR_Msk (1UL << SCB_CFSR_LSPERR_Pos) /*!< SCB CFSR (BFSR): LSPERR Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_STKOF_Pos (SCB_CFSR_USGFAULTSR_Pos + 4U) /*!< SCB CFSR (UFSR): STKOF Position */ +#define SCB_CFSR_STKOF_Msk (1UL << SCB_CFSR_STKOF_Pos) /*!< SCB CFSR (UFSR): STKOF Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/* SCB Non-Secure Access Control Register Definitions */ +#define SCB_NSACR_CP11_Pos 11U /*!< SCB NSACR: CP11 Position */ +#define SCB_NSACR_CP11_Msk (1UL << SCB_NSACR_CP11_Pos) /*!< SCB NSACR: CP11 Mask */ + +#define SCB_NSACR_CP10_Pos 10U /*!< SCB NSACR: CP10 Position */ +#define SCB_NSACR_CP10_Msk (1UL << SCB_NSACR_CP10_Pos) /*!< SCB NSACR: CP10 Mask */ + +#define SCB_NSACR_CPn_Pos 0U /*!< SCB NSACR: CPn Position */ +#define SCB_NSACR_CPn_Msk (1UL /*<< SCB_NSACR_CPn_Pos*/) /*!< SCB NSACR: CPn Mask */ + +/* SCB Cache Level ID Register Definitions */ +#define SCB_CLIDR_LOUU_Pos 27U /*!< SCB CLIDR: LoUU Position */ +#define SCB_CLIDR_LOUU_Msk (7UL << SCB_CLIDR_LOUU_Pos) /*!< SCB CLIDR: LoUU Mask */ + +#define SCB_CLIDR_LOC_Pos 24U /*!< SCB CLIDR: LoC Position */ +#define SCB_CLIDR_LOC_Msk (7UL << SCB_CLIDR_LOC_Pos) /*!< SCB CLIDR: LoC Mask */ + +/* SCB Cache Type Register Definitions */ +#define SCB_CTR_FORMAT_Pos 29U /*!< SCB CTR: Format Position */ +#define SCB_CTR_FORMAT_Msk (7UL << SCB_CTR_FORMAT_Pos) /*!< SCB CTR: Format Mask */ + +#define SCB_CTR_CWG_Pos 24U /*!< SCB CTR: CWG Position */ +#define SCB_CTR_CWG_Msk (0xFUL << SCB_CTR_CWG_Pos) /*!< SCB CTR: CWG Mask */ + +#define SCB_CTR_ERG_Pos 20U /*!< SCB CTR: ERG Position */ +#define SCB_CTR_ERG_Msk (0xFUL << SCB_CTR_ERG_Pos) /*!< SCB CTR: ERG Mask */ + +#define SCB_CTR_DMINLINE_Pos 16U /*!< SCB CTR: DminLine Position */ +#define SCB_CTR_DMINLINE_Msk (0xFUL << SCB_CTR_DMINLINE_Pos) /*!< SCB CTR: DminLine Mask */ + +#define SCB_CTR_IMINLINE_Pos 0U /*!< SCB CTR: ImInLine Position */ +#define SCB_CTR_IMINLINE_Msk (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/) /*!< SCB CTR: ImInLine Mask */ + +/* SCB Cache Size ID Register Definitions */ +#define SCB_CCSIDR_WT_Pos 31U /*!< SCB CCSIDR: WT Position */ +#define SCB_CCSIDR_WT_Msk (1UL << SCB_CCSIDR_WT_Pos) /*!< SCB CCSIDR: WT Mask */ + +#define SCB_CCSIDR_WB_Pos 30U /*!< SCB CCSIDR: WB Position */ +#define SCB_CCSIDR_WB_Msk (1UL << SCB_CCSIDR_WB_Pos) /*!< SCB CCSIDR: WB Mask */ + +#define SCB_CCSIDR_RA_Pos 29U /*!< SCB CCSIDR: RA Position */ +#define SCB_CCSIDR_RA_Msk (1UL << SCB_CCSIDR_RA_Pos) /*!< SCB CCSIDR: RA Mask */ + +#define SCB_CCSIDR_WA_Pos 28U /*!< SCB CCSIDR: WA Position */ +#define SCB_CCSIDR_WA_Msk (1UL << SCB_CCSIDR_WA_Pos) /*!< SCB CCSIDR: WA Mask */ + +#define SCB_CCSIDR_NUMSETS_Pos 13U /*!< SCB CCSIDR: NumSets Position */ +#define SCB_CCSIDR_NUMSETS_Msk (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos) /*!< SCB CCSIDR: NumSets Mask */ + +#define SCB_CCSIDR_ASSOCIATIVITY_Pos 3U /*!< SCB CCSIDR: Associativity Position */ +#define SCB_CCSIDR_ASSOCIATIVITY_Msk (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos) /*!< SCB CCSIDR: Associativity Mask */ + +#define SCB_CCSIDR_LINESIZE_Pos 0U /*!< SCB CCSIDR: LineSize Position */ +#define SCB_CCSIDR_LINESIZE_Msk (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/) /*!< SCB CCSIDR: LineSize Mask */ + +/* SCB Cache Size Selection Register Definitions */ +#define SCB_CSSELR_LEVEL_Pos 1U /*!< SCB CSSELR: Level Position */ +#define SCB_CSSELR_LEVEL_Msk (7UL << SCB_CSSELR_LEVEL_Pos) /*!< SCB CSSELR: Level Mask */ + +#define SCB_CSSELR_IND_Pos 0U /*!< SCB CSSELR: InD Position */ +#define SCB_CSSELR_IND_Msk (1UL /*<< SCB_CSSELR_IND_Pos*/) /*!< SCB CSSELR: InD Mask */ + +/* SCB Software Triggered Interrupt Register Definitions */ +#define SCB_STIR_INTID_Pos 0U /*!< SCB STIR: INTID Position */ +#define SCB_STIR_INTID_Msk (0x1FFUL /*<< SCB_STIR_INTID_Pos*/) /*!< SCB STIR: INTID Mask */ + +/* SCB D-Cache Invalidate by Set-way Register Definitions */ +#define SCB_DCISW_WAY_Pos 30U /*!< SCB DCISW: Way Position */ +#define SCB_DCISW_WAY_Msk (3UL << SCB_DCISW_WAY_Pos) /*!< SCB DCISW: Way Mask */ + +#define SCB_DCISW_SET_Pos 5U /*!< SCB DCISW: Set Position */ +#define SCB_DCISW_SET_Msk (0x1FFUL << SCB_DCISW_SET_Pos) /*!< SCB DCISW: Set Mask */ + +/* SCB D-Cache Clean by Set-way Register Definitions */ +#define SCB_DCCSW_WAY_Pos 30U /*!< SCB DCCSW: Way Position */ +#define SCB_DCCSW_WAY_Msk (3UL << SCB_DCCSW_WAY_Pos) /*!< SCB DCCSW: Way Mask */ + +#define SCB_DCCSW_SET_Pos 5U /*!< SCB DCCSW: Set Position */ +#define SCB_DCCSW_SET_Msk (0x1FFUL << SCB_DCCSW_SET_Pos) /*!< SCB DCCSW: Set Mask */ + +/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */ +#define SCB_DCCISW_WAY_Pos 30U /*!< SCB DCCISW: Way Position */ +#define SCB_DCCISW_WAY_Msk (3UL << SCB_DCCISW_WAY_Pos) /*!< SCB DCCISW: Way Mask */ + +#define SCB_DCCISW_SET_Pos 5U /*!< SCB DCCISW: Set Position */ +#define SCB_DCCISW_SET_Msk (0x1FFUL << SCB_DCCISW_SET_Pos) /*!< SCB DCCISW: Set Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ + __IOM uint32_t CPPWR; /*!< Offset: 0x00C (R/W) Coprocessor Power Control Register */ +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[32U]; + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) ITM Device Architecture Register */ + uint32_t RESERVED6[4U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Stimulus Port Register Definitions */ +#define ITM_STIM_DISABLED_Pos 1U /*!< ITM STIM: DISABLED Position */ +#define ITM_STIM_DISABLED_Msk (0x1UL << ITM_STIM_DISABLED_Pos) /*!< ITM STIM: DISABLED Mask */ + +#define ITM_STIM_FIFOREADY_Pos 0U /*!< ITM STIM: FIFOREADY Position */ +#define ITM_STIM_FIFOREADY_Msk (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/) /*!< ITM STIM: FIFOREADY Mask */ + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TRACEBUSID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TRACEBUSID_Msk (0x7FUL << ITM_TCR_TRACEBUSID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPRESCALE_Pos 8U /*!< ITM TCR: TSPRESCALE Position */ +#define ITM_TCR_TSPRESCALE_Msk (3UL << ITM_TCR_TSPRESCALE_Pos) /*!< ITM TCR: TSPRESCALE Mask */ + +#define ITM_TCR_STALLENA_Pos 5U /*!< ITM TCR: STALLENA Position */ +#define ITM_TCR_STALLENA_Msk (1UL << ITM_TCR_STALLENA_Pos) /*!< ITM TCR: STALLENA Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + uint32_t RESERVED3[1U]; + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED4[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + uint32_t RESERVED5[1U]; + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED6[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + uint32_t RESERVED7[1U]; + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ + uint32_t RESERVED8[1U]; + __IOM uint32_t COMP4; /*!< Offset: 0x060 (R/W) Comparator Register 4 */ + uint32_t RESERVED9[1U]; + __IOM uint32_t FUNCTION4; /*!< Offset: 0x068 (R/W) Function Register 4 */ + uint32_t RESERVED10[1U]; + __IOM uint32_t COMP5; /*!< Offset: 0x070 (R/W) Comparator Register 5 */ + uint32_t RESERVED11[1U]; + __IOM uint32_t FUNCTION5; /*!< Offset: 0x078 (R/W) Function Register 5 */ + uint32_t RESERVED12[1U]; + __IOM uint32_t COMP6; /*!< Offset: 0x080 (R/W) Comparator Register 6 */ + uint32_t RESERVED13[1U]; + __IOM uint32_t FUNCTION6; /*!< Offset: 0x088 (R/W) Function Register 6 */ + uint32_t RESERVED14[1U]; + __IOM uint32_t COMP7; /*!< Offset: 0x090 (R/W) Comparator Register 7 */ + uint32_t RESERVED15[1U]; + __IOM uint32_t FUNCTION7; /*!< Offset: 0x098 (R/W) Function Register 7 */ + uint32_t RESERVED16[1U]; + __IOM uint32_t COMP8; /*!< Offset: 0x0A0 (R/W) Comparator Register 8 */ + uint32_t RESERVED17[1U]; + __IOM uint32_t FUNCTION8; /*!< Offset: 0x0A8 (R/W) Function Register 8 */ + uint32_t RESERVED18[1U]; + __IOM uint32_t COMP9; /*!< Offset: 0x0B0 (R/W) Comparator Register 9 */ + uint32_t RESERVED19[1U]; + __IOM uint32_t FUNCTION9; /*!< Offset: 0x0B8 (R/W) Function Register 9 */ + uint32_t RESERVED20[1U]; + __IOM uint32_t COMP10; /*!< Offset: 0x0C0 (R/W) Comparator Register 10 */ + uint32_t RESERVED21[1U]; + __IOM uint32_t FUNCTION10; /*!< Offset: 0x0C8 (R/W) Function Register 10 */ + uint32_t RESERVED22[1U]; + __IOM uint32_t COMP11; /*!< Offset: 0x0D0 (R/W) Comparator Register 11 */ + uint32_t RESERVED23[1U]; + __IOM uint32_t FUNCTION11; /*!< Offset: 0x0D8 (R/W) Function Register 11 */ + uint32_t RESERVED24[1U]; + __IOM uint32_t COMP12; /*!< Offset: 0x0E0 (R/W) Comparator Register 12 */ + uint32_t RESERVED25[1U]; + __IOM uint32_t FUNCTION12; /*!< Offset: 0x0E8 (R/W) Function Register 12 */ + uint32_t RESERVED26[1U]; + __IOM uint32_t COMP13; /*!< Offset: 0x0F0 (R/W) Comparator Register 13 */ + uint32_t RESERVED27[1U]; + __IOM uint32_t FUNCTION13; /*!< Offset: 0x0F8 (R/W) Function Register 13 */ + uint32_t RESERVED28[1U]; + __IOM uint32_t COMP14; /*!< Offset: 0x100 (R/W) Comparator Register 14 */ + uint32_t RESERVED29[1U]; + __IOM uint32_t FUNCTION14; /*!< Offset: 0x108 (R/W) Function Register 14 */ + uint32_t RESERVED30[1U]; + __IOM uint32_t COMP15; /*!< Offset: 0x110 (R/W) Comparator Register 15 */ + uint32_t RESERVED31[1U]; + __IOM uint32_t FUNCTION15; /*!< Offset: 0x118 (R/W) Function Register 15 */ + uint32_t RESERVED32[934U]; + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R ) Lock Status Register */ + uint32_t RESERVED33[1U]; + __IM uint32_t DEVARCH; /*!< Offset: 0xFBC (R/ ) Device Architecture Register */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCDISS_Pos 23U /*!< DWT CTRL: CYCDISS Position */ +#define DWT_CTRL_CYCDISS_Msk (0x1UL << DWT_CTRL_CYCDISS_Pos) /*!< DWT CTRL: CYCDISS Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_ID_Pos 27U /*!< DWT FUNCTION: ID Position */ +#define DWT_FUNCTION_ID_Msk (0x1FUL << DWT_FUNCTION_ID_Pos) /*!< DWT FUNCTION: ID Mask */ + +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_ACTION_Pos 4U /*!< DWT FUNCTION: ACTION Position */ +#define DWT_FUNCTION_ACTION_Msk (0x1UL << DWT_FUNCTION_ACTION_Pos) /*!< DWT FUNCTION: ACTION Mask */ + +#define DWT_FUNCTION_MATCH_Pos 0U /*!< DWT FUNCTION: MATCH Position */ +#define DWT_FUNCTION_MATCH_Msk (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/) /*!< DWT FUNCTION: MATCH Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IOM uint32_t PSCR; /*!< Offset: 0x308 (R/W) Periodic Synchronization Control Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER Register */ + __IM uint32_t ITFTTD0; /*!< Offset: 0xEEC (R/ ) Integration Test FIFO Test Data 0 Register */ + __IOM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/W) Integration Test ATB Control Register 2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) Integration Test ATB Control Register 0 */ + __IM uint32_t ITFTTD1; /*!< Offset: 0xEFC (R/ ) Integration Test FIFO Test Data 1 Register */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) Device Configuration Register */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) Device Type Identifier Register */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_FOnMan_Pos 6U /*!< TPI FFCR: FOnMan Position */ +#define TPI_FFCR_FOnMan_Msk (0x1UL << TPI_FFCR_FOnMan_Pos) /*!< TPI FFCR: FOnMan Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration Test FIFO Test Data 0 Register Definitions */ +#define TPI_ITFTTD0_ATB_IF2_ATVALID_Pos 29U /*!< TPI ITFTTD0: ATB Interface 2 ATVALIDPosition */ +#define TPI_ITFTTD0_ATB_IF2_ATVALID_Msk (0x3UL << TPI_ITFTTD0_ATB_IF2_ATVALID_Pos) /*!< TPI ITFTTD0: ATB Interface 2 ATVALID Mask */ + +#define TPI_ITFTTD0_ATB_IF2_bytecount_Pos 27U /*!< TPI ITFTTD0: ATB Interface 2 byte count Position */ +#define TPI_ITFTTD0_ATB_IF2_bytecount_Msk (0x3UL << TPI_ITFTTD0_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 2 byte count Mask */ + +#define TPI_ITFTTD0_ATB_IF1_ATVALID_Pos 26U /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Position */ +#define TPI_ITFTTD0_ATB_IF1_ATVALID_Msk (0x3UL << TPI_ITFTTD0_ATB_IF1_ATVALID_Pos) /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Mask */ + +#define TPI_ITFTTD0_ATB_IF1_bytecount_Pos 24U /*!< TPI ITFTTD0: ATB Interface 1 byte count Position */ +#define TPI_ITFTTD0_ATB_IF1_bytecount_Msk (0x3UL << TPI_ITFTTD0_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 1 byte countt Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data2_Pos 16U /*!< TPI ITFTTD0: ATB Interface 1 data2 Position */ +#define TPI_ITFTTD0_ATB_IF1_data2_Msk (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos) /*!< TPI ITFTTD0: ATB Interface 1 data2 Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data1_Pos 8U /*!< TPI ITFTTD0: ATB Interface 1 data1 Position */ +#define TPI_ITFTTD0_ATB_IF1_data1_Msk (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos) /*!< TPI ITFTTD0: ATB Interface 1 data1 Mask */ + +#define TPI_ITFTTD0_ATB_IF1_data0_Pos 0U /*!< TPI ITFTTD0: ATB Interface 1 data0 Position */ +#define TPI_ITFTTD0_ATB_IF1_data0_Msk (0xFFUL /*<< TPI_ITFTTD0_ATB_IF1_data0_Pos*/) /*!< TPI ITFTTD0: ATB Interface 1 data0 Mask */ + +/* TPI Integration Test ATB Control Register 2 Register Definitions */ +#define TPI_ITATBCTR2_AFVALID2S_Pos 1U /*!< TPI ITATBCTR2: AFVALID2S Position */ +#define TPI_ITATBCTR2_AFVALID2S_Msk (0x1UL << TPI_ITATBCTR2_AFVALID2S_Pos) /*!< TPI ITATBCTR2: AFVALID2SS Mask */ + +#define TPI_ITATBCTR2_AFVALID1S_Pos 1U /*!< TPI ITATBCTR2: AFVALID1S Position */ +#define TPI_ITATBCTR2_AFVALID1S_Msk (0x1UL << TPI_ITATBCTR2_AFVALID1S_Pos) /*!< TPI ITATBCTR2: AFVALID1SS Mask */ + +#define TPI_ITATBCTR2_ATREADY2S_Pos 0U /*!< TPI ITATBCTR2: ATREADY2S Position */ +#define TPI_ITATBCTR2_ATREADY2S_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY2S_Pos*/) /*!< TPI ITATBCTR2: ATREADY2S Mask */ + +#define TPI_ITATBCTR2_ATREADY1S_Pos 0U /*!< TPI ITATBCTR2: ATREADY1S Position */ +#define TPI_ITATBCTR2_ATREADY1S_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY1S_Pos*/) /*!< TPI ITATBCTR2: ATREADY1S Mask */ + +/* TPI Integration Test FIFO Test Data 1 Register Definitions */ +#define TPI_ITFTTD1_ATB_IF2_ATVALID_Pos 29U /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Position */ +#define TPI_ITFTTD1_ATB_IF2_ATVALID_Msk (0x3UL << TPI_ITFTTD1_ATB_IF2_ATVALID_Pos) /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Mask */ + +#define TPI_ITFTTD1_ATB_IF2_bytecount_Pos 27U /*!< TPI ITFTTD1: ATB Interface 2 byte count Position */ +#define TPI_ITFTTD1_ATB_IF2_bytecount_Msk (0x3UL << TPI_ITFTTD1_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 2 byte count Mask */ + +#define TPI_ITFTTD1_ATB_IF1_ATVALID_Pos 26U /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Position */ +#define TPI_ITFTTD1_ATB_IF1_ATVALID_Msk (0x3UL << TPI_ITFTTD1_ATB_IF1_ATVALID_Pos) /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Mask */ + +#define TPI_ITFTTD1_ATB_IF1_bytecount_Pos 24U /*!< TPI ITFTTD1: ATB Interface 1 byte count Position */ +#define TPI_ITFTTD1_ATB_IF1_bytecount_Msk (0x3UL << TPI_ITFTTD1_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 1 byte countt Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data2_Pos 16U /*!< TPI ITFTTD1: ATB Interface 2 data2 Position */ +#define TPI_ITFTTD1_ATB_IF2_data2_Msk (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos) /*!< TPI ITFTTD1: ATB Interface 2 data2 Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data1_Pos 8U /*!< TPI ITFTTD1: ATB Interface 2 data1 Position */ +#define TPI_ITFTTD1_ATB_IF2_data1_Msk (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos) /*!< TPI ITFTTD1: ATB Interface 2 data1 Mask */ + +#define TPI_ITFTTD1_ATB_IF2_data0_Pos 0U /*!< TPI ITFTTD1: ATB Interface 2 data0 Position */ +#define TPI_ITFTTD1_ATB_IF2_data0_Msk (0xFFUL /*<< TPI_ITFTTD1_ATB_IF2_data0_Pos*/) /*!< TPI ITFTTD1: ATB Interface 2 data0 Mask */ + +/* TPI Integration Test ATB Control Register 0 Definitions */ +#define TPI_ITATBCTR0_AFVALID2S_Pos 1U /*!< TPI ITATBCTR0: AFVALID2S Position */ +#define TPI_ITATBCTR0_AFVALID2S_Msk (0x1UL << TPI_ITATBCTR0_AFVALID2S_Pos) /*!< TPI ITATBCTR0: AFVALID2SS Mask */ + +#define TPI_ITATBCTR0_AFVALID1S_Pos 1U /*!< TPI ITATBCTR0: AFVALID1S Position */ +#define TPI_ITATBCTR0_AFVALID1S_Msk (0x1UL << TPI_ITATBCTR0_AFVALID1S_Pos) /*!< TPI ITATBCTR0: AFVALID1SS Mask */ + +#define TPI_ITATBCTR0_ATREADY2S_Pos 0U /*!< TPI ITATBCTR0: ATREADY2S Position */ +#define TPI_ITATBCTR0_ATREADY2S_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY2S_Pos*/) /*!< TPI ITATBCTR0: ATREADY2S Mask */ + +#define TPI_ITATBCTR0_ATREADY1S_Pos 0U /*!< TPI ITATBCTR0: ATREADY1S Position */ +#define TPI_ITATBCTR0_ATREADY1S_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY1S_Pos*/) /*!< TPI ITATBCTR0: ATREADY1S Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_FIFOSZ_Pos 6U /*!< TPI DEVID: FIFOSZ Position */ +#define TPI_DEVID_FIFOSZ_Msk (0x7UL << TPI_DEVID_FIFOSZ_Pos) /*!< TPI DEVID: FIFOSZ Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x3FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) MPU Region Limit Address Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Region Base Address Register Alias 1 */ + __IOM uint32_t RLAR_A1; /*!< Offset: 0x018 (R/W) MPU Region Limit Address Register Alias 1 */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Region Base Address Register Alias 2 */ + __IOM uint32_t RLAR_A2; /*!< Offset: 0x020 (R/W) MPU Region Limit Address Register Alias 2 */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Region Base Address Register Alias 3 */ + __IOM uint32_t RLAR_A3; /*!< Offset: 0x028 (R/W) MPU Region Limit Address Register Alias 3 */ + uint32_t RESERVED0[1]; + union { + __IOM uint32_t MAIR[2]; + struct { + __IOM uint32_t MAIR0; /*!< Offset: 0x030 (R/W) MPU Memory Attribute Indirection Register 0 */ + __IOM uint32_t MAIR1; /*!< Offset: 0x034 (R/W) MPU Memory Attribute Indirection Register 1 */ + }; + }; +} MPU_Type; + +#define MPU_TYPE_RALIASES 4U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_BASE_Pos 5U /*!< MPU RBAR: BASE Position */ +#define MPU_RBAR_BASE_Msk (0x7FFFFFFUL << MPU_RBAR_BASE_Pos) /*!< MPU RBAR: BASE Mask */ + +#define MPU_RBAR_SH_Pos 3U /*!< MPU RBAR: SH Position */ +#define MPU_RBAR_SH_Msk (0x3UL << MPU_RBAR_SH_Pos) /*!< MPU RBAR: SH Mask */ + +#define MPU_RBAR_AP_Pos 1U /*!< MPU RBAR: AP Position */ +#define MPU_RBAR_AP_Msk (0x3UL << MPU_RBAR_AP_Pos) /*!< MPU RBAR: AP Mask */ + +#define MPU_RBAR_XN_Pos 0U /*!< MPU RBAR: XN Position */ +#define MPU_RBAR_XN_Msk (01UL /*<< MPU_RBAR_XN_Pos*/) /*!< MPU RBAR: XN Mask */ + +/* MPU Region Limit Address Register Definitions */ +#define MPU_RLAR_LIMIT_Pos 5U /*!< MPU RLAR: LIMIT Position */ +#define MPU_RLAR_LIMIT_Msk (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos) /*!< MPU RLAR: LIMIT Mask */ + +#define MPU_RLAR_AttrIndx_Pos 1U /*!< MPU RLAR: AttrIndx Position */ +#define MPU_RLAR_AttrIndx_Msk (0x7UL << MPU_RLAR_AttrIndx_Pos) /*!< MPU RLAR: AttrIndx Mask */ + +#define MPU_RLAR_EN_Pos 0U /*!< MPU RLAR: Region enable bit Position */ +#define MPU_RLAR_EN_Msk (1UL /*<< MPU_RLAR_EN_Pos*/) /*!< MPU RLAR: Region enable bit Disable Mask */ + +/* MPU Memory Attribute Indirection Register 0 Definitions */ +#define MPU_MAIR0_Attr3_Pos 24U /*!< MPU MAIR0: Attr3 Position */ +#define MPU_MAIR0_Attr3_Msk (0xFFUL << MPU_MAIR0_Attr3_Pos) /*!< MPU MAIR0: Attr3 Mask */ + +#define MPU_MAIR0_Attr2_Pos 16U /*!< MPU MAIR0: Attr2 Position */ +#define MPU_MAIR0_Attr2_Msk (0xFFUL << MPU_MAIR0_Attr2_Pos) /*!< MPU MAIR0: Attr2 Mask */ + +#define MPU_MAIR0_Attr1_Pos 8U /*!< MPU MAIR0: Attr1 Position */ +#define MPU_MAIR0_Attr1_Msk (0xFFUL << MPU_MAIR0_Attr1_Pos) /*!< MPU MAIR0: Attr1 Mask */ + +#define MPU_MAIR0_Attr0_Pos 0U /*!< MPU MAIR0: Attr0 Position */ +#define MPU_MAIR0_Attr0_Msk (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/) /*!< MPU MAIR0: Attr0 Mask */ + +/* MPU Memory Attribute Indirection Register 1 Definitions */ +#define MPU_MAIR1_Attr7_Pos 24U /*!< MPU MAIR1: Attr7 Position */ +#define MPU_MAIR1_Attr7_Msk (0xFFUL << MPU_MAIR1_Attr7_Pos) /*!< MPU MAIR1: Attr7 Mask */ + +#define MPU_MAIR1_Attr6_Pos 16U /*!< MPU MAIR1: Attr6 Position */ +#define MPU_MAIR1_Attr6_Msk (0xFFUL << MPU_MAIR1_Attr6_Pos) /*!< MPU MAIR1: Attr6 Mask */ + +#define MPU_MAIR1_Attr5_Pos 8U /*!< MPU MAIR1: Attr5 Position */ +#define MPU_MAIR1_Attr5_Msk (0xFFUL << MPU_MAIR1_Attr5_Pos) /*!< MPU MAIR1: Attr5 Mask */ + +#define MPU_MAIR1_Attr4_Pos 0U /*!< MPU MAIR1: Attr4 Position */ +#define MPU_MAIR1_Attr4_Msk (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/) /*!< MPU MAIR1: Attr4 Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SAU Security Attribution Unit (SAU) + \brief Type definitions for the Security Attribution Unit (SAU) + @{ + */ + +/** + \brief Structure type to access the Security Attribution Unit (SAU). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SAU Control Register */ + __IM uint32_t TYPE; /*!< Offset: 0x004 (R/ ) SAU Type Register */ +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) SAU Region Number Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) SAU Region Base Address Register */ + __IOM uint32_t RLAR; /*!< Offset: 0x010 (R/W) SAU Region Limit Address Register */ +#else + uint32_t RESERVED0[3]; +#endif + __IOM uint32_t SFSR; /*!< Offset: 0x014 (R/W) Secure Fault Status Register */ + __IOM uint32_t SFAR; /*!< Offset: 0x018 (R/W) Secure Fault Address Register */ +} SAU_Type; + +/* SAU Control Register Definitions */ +#define SAU_CTRL_ALLNS_Pos 1U /*!< SAU CTRL: ALLNS Position */ +#define SAU_CTRL_ALLNS_Msk (1UL << SAU_CTRL_ALLNS_Pos) /*!< SAU CTRL: ALLNS Mask */ + +#define SAU_CTRL_ENABLE_Pos 0U /*!< SAU CTRL: ENABLE Position */ +#define SAU_CTRL_ENABLE_Msk (1UL /*<< SAU_CTRL_ENABLE_Pos*/) /*!< SAU CTRL: ENABLE Mask */ + +/* SAU Type Register Definitions */ +#define SAU_TYPE_SREGION_Pos 0U /*!< SAU TYPE: SREGION Position */ +#define SAU_TYPE_SREGION_Msk (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/) /*!< SAU TYPE: SREGION Mask */ + +#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) +/* SAU Region Number Register Definitions */ +#define SAU_RNR_REGION_Pos 0U /*!< SAU RNR: REGION Position */ +#define SAU_RNR_REGION_Msk (0xFFUL /*<< SAU_RNR_REGION_Pos*/) /*!< SAU RNR: REGION Mask */ + +/* SAU Region Base Address Register Definitions */ +#define SAU_RBAR_BADDR_Pos 5U /*!< SAU RBAR: BADDR Position */ +#define SAU_RBAR_BADDR_Msk (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos) /*!< SAU RBAR: BADDR Mask */ + +/* SAU Region Limit Address Register Definitions */ +#define SAU_RLAR_LADDR_Pos 5U /*!< SAU RLAR: LADDR Position */ +#define SAU_RLAR_LADDR_Msk (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos) /*!< SAU RLAR: LADDR Mask */ + +#define SAU_RLAR_NSC_Pos 1U /*!< SAU RLAR: NSC Position */ +#define SAU_RLAR_NSC_Msk (1UL << SAU_RLAR_NSC_Pos) /*!< SAU RLAR: NSC Mask */ + +#define SAU_RLAR_ENABLE_Pos 0U /*!< SAU RLAR: ENABLE Position */ +#define SAU_RLAR_ENABLE_Msk (1UL /*<< SAU_RLAR_ENABLE_Pos*/) /*!< SAU RLAR: ENABLE Mask */ + +#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */ + +/* Secure Fault Status Register Definitions */ +#define SAU_SFSR_LSERR_Pos 7U /*!< SAU SFSR: LSERR Position */ +#define SAU_SFSR_LSERR_Msk (1UL << SAU_SFSR_LSERR_Pos) /*!< SAU SFSR: LSERR Mask */ + +#define SAU_SFSR_SFARVALID_Pos 6U /*!< SAU SFSR: SFARVALID Position */ +#define SAU_SFSR_SFARVALID_Msk (1UL << SAU_SFSR_SFARVALID_Pos) /*!< SAU SFSR: SFARVALID Mask */ + +#define SAU_SFSR_LSPERR_Pos 5U /*!< SAU SFSR: LSPERR Position */ +#define SAU_SFSR_LSPERR_Msk (1UL << SAU_SFSR_LSPERR_Pos) /*!< SAU SFSR: LSPERR Mask */ + +#define SAU_SFSR_INVTRAN_Pos 4U /*!< SAU SFSR: INVTRAN Position */ +#define SAU_SFSR_INVTRAN_Msk (1UL << SAU_SFSR_INVTRAN_Pos) /*!< SAU SFSR: INVTRAN Mask */ + +#define SAU_SFSR_AUVIOL_Pos 3U /*!< SAU SFSR: AUVIOL Position */ +#define SAU_SFSR_AUVIOL_Msk (1UL << SAU_SFSR_AUVIOL_Pos) /*!< SAU SFSR: AUVIOL Mask */ + +#define SAU_SFSR_INVER_Pos 2U /*!< SAU SFSR: INVER Position */ +#define SAU_SFSR_INVER_Msk (1UL << SAU_SFSR_INVER_Pos) /*!< SAU SFSR: INVER Mask */ + +#define SAU_SFSR_INVIS_Pos 1U /*!< SAU SFSR: INVIS Position */ +#define SAU_SFSR_INVIS_Msk (1UL << SAU_SFSR_INVIS_Pos) /*!< SAU SFSR: INVIS Mask */ + +#define SAU_SFSR_INVEP_Pos 0U /*!< SAU SFSR: INVEP Position */ +#define SAU_SFSR_INVEP_Msk (1UL /*<< SAU_SFSR_INVEP_Pos*/) /*!< SAU SFSR: INVEP Mask */ + +/*@} end of group CMSIS_SAU */ +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_FPU Floating Point Unit (FPU) + \brief Type definitions for the Floating Point Unit (FPU) + @{ + */ + +/** + \brief Structure type to access the Floating Point Unit (FPU). + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IOM uint32_t FPCCR; /*!< Offset: 0x004 (R/W) Floating-Point Context Control Register */ + __IOM uint32_t FPCAR; /*!< Offset: 0x008 (R/W) Floating-Point Context Address Register */ + __IOM uint32_t FPDSCR; /*!< Offset: 0x00C (R/W) Floating-Point Default Status Control Register */ + __IM uint32_t MVFR0; /*!< Offset: 0x010 (R/ ) Media and FP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x014 (R/ ) Media and FP Feature Register 1 */ +} FPU_Type; + +/* Floating-Point Context Control Register Definitions */ +#define FPU_FPCCR_ASPEN_Pos 31U /*!< FPCCR: ASPEN bit Position */ +#define FPU_FPCCR_ASPEN_Msk (1UL << FPU_FPCCR_ASPEN_Pos) /*!< FPCCR: ASPEN bit Mask */ + +#define FPU_FPCCR_LSPEN_Pos 30U /*!< FPCCR: LSPEN Position */ +#define FPU_FPCCR_LSPEN_Msk (1UL << FPU_FPCCR_LSPEN_Pos) /*!< FPCCR: LSPEN bit Mask */ + +#define FPU_FPCCR_LSPENS_Pos 29U /*!< FPCCR: LSPENS Position */ +#define FPU_FPCCR_LSPENS_Msk (1UL << FPU_FPCCR_LSPENS_Pos) /*!< FPCCR: LSPENS bit Mask */ + +#define FPU_FPCCR_CLRONRET_Pos 28U /*!< FPCCR: CLRONRET Position */ +#define FPU_FPCCR_CLRONRET_Msk (1UL << FPU_FPCCR_CLRONRET_Pos) /*!< FPCCR: CLRONRET bit Mask */ + +#define FPU_FPCCR_CLRONRETS_Pos 27U /*!< FPCCR: CLRONRETS Position */ +#define FPU_FPCCR_CLRONRETS_Msk (1UL << FPU_FPCCR_CLRONRETS_Pos) /*!< FPCCR: CLRONRETS bit Mask */ + +#define FPU_FPCCR_TS_Pos 26U /*!< FPCCR: TS Position */ +#define FPU_FPCCR_TS_Msk (1UL << FPU_FPCCR_TS_Pos) /*!< FPCCR: TS bit Mask */ + +#define FPU_FPCCR_UFRDY_Pos 10U /*!< FPCCR: UFRDY Position */ +#define FPU_FPCCR_UFRDY_Msk (1UL << FPU_FPCCR_UFRDY_Pos) /*!< FPCCR: UFRDY bit Mask */ + +#define FPU_FPCCR_SPLIMVIOL_Pos 9U /*!< FPCCR: SPLIMVIOL Position */ +#define FPU_FPCCR_SPLIMVIOL_Msk (1UL << FPU_FPCCR_SPLIMVIOL_Pos) /*!< FPCCR: SPLIMVIOL bit Mask */ + +#define FPU_FPCCR_MONRDY_Pos 8U /*!< FPCCR: MONRDY Position */ +#define FPU_FPCCR_MONRDY_Msk (1UL << FPU_FPCCR_MONRDY_Pos) /*!< FPCCR: MONRDY bit Mask */ + +#define FPU_FPCCR_SFRDY_Pos 7U /*!< FPCCR: SFRDY Position */ +#define FPU_FPCCR_SFRDY_Msk (1UL << FPU_FPCCR_SFRDY_Pos) /*!< FPCCR: SFRDY bit Mask */ + +#define FPU_FPCCR_BFRDY_Pos 6U /*!< FPCCR: BFRDY Position */ +#define FPU_FPCCR_BFRDY_Msk (1UL << FPU_FPCCR_BFRDY_Pos) /*!< FPCCR: BFRDY bit Mask */ + +#define FPU_FPCCR_MMRDY_Pos 5U /*!< FPCCR: MMRDY Position */ +#define FPU_FPCCR_MMRDY_Msk (1UL << FPU_FPCCR_MMRDY_Pos) /*!< FPCCR: MMRDY bit Mask */ + +#define FPU_FPCCR_HFRDY_Pos 4U /*!< FPCCR: HFRDY Position */ +#define FPU_FPCCR_HFRDY_Msk (1UL << FPU_FPCCR_HFRDY_Pos) /*!< FPCCR: HFRDY bit Mask */ + +#define FPU_FPCCR_THREAD_Pos 3U /*!< FPCCR: processor mode bit Position */ +#define FPU_FPCCR_THREAD_Msk (1UL << FPU_FPCCR_THREAD_Pos) /*!< FPCCR: processor mode active bit Mask */ + +#define FPU_FPCCR_S_Pos 2U /*!< FPCCR: Security status of the FP context bit Position */ +#define FPU_FPCCR_S_Msk (1UL << FPU_FPCCR_S_Pos) /*!< FPCCR: Security status of the FP context bit Mask */ + +#define FPU_FPCCR_USER_Pos 1U /*!< FPCCR: privilege level bit Position */ +#define FPU_FPCCR_USER_Msk (1UL << FPU_FPCCR_USER_Pos) /*!< FPCCR: privilege level bit Mask */ + +#define FPU_FPCCR_LSPACT_Pos 0U /*!< FPCCR: Lazy state preservation active bit Position */ +#define FPU_FPCCR_LSPACT_Msk (1UL /*<< FPU_FPCCR_LSPACT_Pos*/) /*!< FPCCR: Lazy state preservation active bit Mask */ + +/* Floating-Point Context Address Register Definitions */ +#define FPU_FPCAR_ADDRESS_Pos 3U /*!< FPCAR: ADDRESS bit Position */ +#define FPU_FPCAR_ADDRESS_Msk (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos) /*!< FPCAR: ADDRESS bit Mask */ + +/* Floating-Point Default Status Control Register Definitions */ +#define FPU_FPDSCR_AHP_Pos 26U /*!< FPDSCR: AHP bit Position */ +#define FPU_FPDSCR_AHP_Msk (1UL << FPU_FPDSCR_AHP_Pos) /*!< FPDSCR: AHP bit Mask */ + +#define FPU_FPDSCR_DN_Pos 25U /*!< FPDSCR: DN bit Position */ +#define FPU_FPDSCR_DN_Msk (1UL << FPU_FPDSCR_DN_Pos) /*!< FPDSCR: DN bit Mask */ + +#define FPU_FPDSCR_FZ_Pos 24U /*!< FPDSCR: FZ bit Position */ +#define FPU_FPDSCR_FZ_Msk (1UL << FPU_FPDSCR_FZ_Pos) /*!< FPDSCR: FZ bit Mask */ + +#define FPU_FPDSCR_RMode_Pos 22U /*!< FPDSCR: RMode bit Position */ +#define FPU_FPDSCR_RMode_Msk (3UL << FPU_FPDSCR_RMode_Pos) /*!< FPDSCR: RMode bit Mask */ + +/* Media and FP Feature Register 0 Definitions */ +#define FPU_MVFR0_FP_rounding_modes_Pos 28U /*!< MVFR0: FP rounding modes bits Position */ +#define FPU_MVFR0_FP_rounding_modes_Msk (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos) /*!< MVFR0: FP rounding modes bits Mask */ + +#define FPU_MVFR0_Short_vectors_Pos 24U /*!< MVFR0: Short vectors bits Position */ +#define FPU_MVFR0_Short_vectors_Msk (0xFUL << FPU_MVFR0_Short_vectors_Pos) /*!< MVFR0: Short vectors bits Mask */ + +#define FPU_MVFR0_Square_root_Pos 20U /*!< MVFR0: Square root bits Position */ +#define FPU_MVFR0_Square_root_Msk (0xFUL << FPU_MVFR0_Square_root_Pos) /*!< MVFR0: Square root bits Mask */ + +#define FPU_MVFR0_Divide_Pos 16U /*!< MVFR0: Divide bits Position */ +#define FPU_MVFR0_Divide_Msk (0xFUL << FPU_MVFR0_Divide_Pos) /*!< MVFR0: Divide bits Mask */ + +#define FPU_MVFR0_FP_excep_trapping_Pos 12U /*!< MVFR0: FP exception trapping bits Position */ +#define FPU_MVFR0_FP_excep_trapping_Msk (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos) /*!< MVFR0: FP exception trapping bits Mask */ + +#define FPU_MVFR0_Double_precision_Pos 8U /*!< MVFR0: Double-precision bits Position */ +#define FPU_MVFR0_Double_precision_Msk (0xFUL << FPU_MVFR0_Double_precision_Pos) /*!< MVFR0: Double-precision bits Mask */ + +#define FPU_MVFR0_Single_precision_Pos 4U /*!< MVFR0: Single-precision bits Position */ +#define FPU_MVFR0_Single_precision_Msk (0xFUL << FPU_MVFR0_Single_precision_Pos) /*!< MVFR0: Single-precision bits Mask */ + +#define FPU_MVFR0_A_SIMD_registers_Pos 0U /*!< MVFR0: A_SIMD registers bits Position */ +#define FPU_MVFR0_A_SIMD_registers_Msk (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/) /*!< MVFR0: A_SIMD registers bits Mask */ + +/* Media and FP Feature Register 1 Definitions */ +#define FPU_MVFR1_FP_fused_MAC_Pos 28U /*!< MVFR1: FP fused MAC bits Position */ +#define FPU_MVFR1_FP_fused_MAC_Msk (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos) /*!< MVFR1: FP fused MAC bits Mask */ + +#define FPU_MVFR1_FP_HPFP_Pos 24U /*!< MVFR1: FP HPFP bits Position */ +#define FPU_MVFR1_FP_HPFP_Msk (0xFUL << FPU_MVFR1_FP_HPFP_Pos) /*!< MVFR1: FP HPFP bits Mask */ + +#define FPU_MVFR1_D_NaN_mode_Pos 4U /*!< MVFR1: D_NaN mode bits Position */ +#define FPU_MVFR1_D_NaN_mode_Msk (0xFUL << FPU_MVFR1_D_NaN_mode_Pos) /*!< MVFR1: D_NaN mode bits Mask */ + +#define FPU_MVFR1_FtZ_mode_Pos 0U /*!< MVFR1: FtZ mode bits Position */ +#define FPU_MVFR1_FtZ_mode_Msk (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/) /*!< MVFR1: FtZ mode bits Mask */ + +/*@} end of group CMSIS_FPU */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ + uint32_t RESERVED4[1U]; + __IOM uint32_t DAUTHCTRL; /*!< Offset: 0x014 (R/W) Debug Authentication Control Register */ + __IOM uint32_t DSCSR; /*!< Offset: 0x018 (R/W) Debug Security Control and Status Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESTART_ST_Pos 26U /*!< CoreDebug DHCSR: S_RESTART_ST Position */ +#define CoreDebug_DHCSR_S_RESTART_ST_Msk (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos) /*!< CoreDebug DHCSR: S_RESTART_ST Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/* Debug Authentication Control Register Definitions */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos 3U /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */ +#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */ + +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos 2U /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos) /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */ + +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos 1U /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */ +#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos) /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */ + +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos 0U /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */ +#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */ + +/* Debug Security Control and Status Register Definitions */ +#define CoreDebug_DSCSR_CDS_Pos 16U /*!< CoreDebug DSCSR: CDS Position */ +#define CoreDebug_DSCSR_CDS_Msk (1UL << CoreDebug_DSCSR_CDS_Pos) /*!< CoreDebug DSCSR: CDS Mask */ + +#define CoreDebug_DSCSR_SBRSEL_Pos 1U /*!< CoreDebug DSCSR: SBRSEL Position */ +#define CoreDebug_DSCSR_SBRSEL_Msk (1UL << CoreDebug_DSCSR_SBRSEL_Pos) /*!< CoreDebug DSCSR: SBRSEL Mask */ + +#define CoreDebug_DSCSR_SBRSELEN_Pos 0U /*!< CoreDebug DSCSR: SBRSELEN Position */ +#define CoreDebug_DSCSR_SBRSELEN_Msk (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/) /*!< CoreDebug DSCSR: SBRSELEN Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ + #define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ + #define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ + #define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ + #define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ + #define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ + #define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ + #define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ + #define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + + #define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ + #define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ + #define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ + #define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + #define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ + #define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ + #define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ + #define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE ) /*!< Core Debug configuration struct */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ + #endif + + #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SAU_BASE (SCS_BASE + 0x0DD0UL) /*!< Security Attribution Unit */ + #define SAU ((SAU_Type *) SAU_BASE ) /*!< Security Attribution Unit */ + #endif + + #define FPU_BASE (SCS_BASE + 0x0F30UL) /*!< Floating Point Unit */ + #define FPU ((FPU_Type *) FPU_BASE ) /*!< Floating Point Unit */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + #define SCS_BASE_NS (0xE002E000UL) /*!< System Control Space Base Address (non-secure address space) */ + #define CoreDebug_BASE_NS (0xE002EDF0UL) /*!< Core Debug Base Address (non-secure address space) */ + #define SysTick_BASE_NS (SCS_BASE_NS + 0x0010UL) /*!< SysTick Base Address (non-secure address space) */ + #define NVIC_BASE_NS (SCS_BASE_NS + 0x0100UL) /*!< NVIC Base Address (non-secure address space) */ + #define SCB_BASE_NS (SCS_BASE_NS + 0x0D00UL) /*!< System Control Block Base Address (non-secure address space) */ + + #define SCnSCB_NS ((SCnSCB_Type *) SCS_BASE_NS ) /*!< System control Register not in SCB(non-secure address space) */ + #define SCB_NS ((SCB_Type *) SCB_BASE_NS ) /*!< SCB configuration struct (non-secure address space) */ + #define SysTick_NS ((SysTick_Type *) SysTick_BASE_NS ) /*!< SysTick configuration struct (non-secure address space) */ + #define NVIC_NS ((NVIC_Type *) NVIC_BASE_NS ) /*!< NVIC configuration struct (non-secure address space) */ + #define CoreDebug_NS ((CoreDebug_Type *) CoreDebug_BASE_NS) /*!< Core Debug configuration struct (non-secure address space) */ + + #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE_NS (SCS_BASE_NS + 0x0D90UL) /*!< Memory Protection Unit (non-secure address space) */ + #define MPU_NS ((MPU_Type *) MPU_BASE_NS ) /*!< Memory Protection Unit (non-secure address space) */ + #endif + + #define FPU_BASE_NS (SCS_BASE_NS + 0x0F30UL) /*!< Floating Point Unit (non-secure address space) */ + #define FPU_NS ((FPU_Type *) FPU_BASE_NS ) /*!< Floating Point Unit (non-secure address space) */ + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* Special LR values for Secure/Non-Secure call handling and exception handling */ + +/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS */ +#define FNC_RETURN (0xFEFFFFFFUL) /* bit [0] ignored when processing a branch */ + +/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */ +#define EXC_RETURN_PREFIX (0xFF000000UL) /* bits [31:24] set to indicate an EXC_RETURN value */ +#define EXC_RETURN_S (0x00000040UL) /* bit [6] stack used to push registers: 0=Non-secure 1=Secure */ +#define EXC_RETURN_DCRS (0x00000020UL) /* bit [5] stacking rules for called registers: 0=skipped 1=saved */ +#define EXC_RETURN_FTYPE (0x00000010UL) /* bit [4] allocate stack for floating-point context: 0=done 1=skipped */ +#define EXC_RETURN_MODE (0x00000008UL) /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode */ +#define EXC_RETURN_SPSEL (0x00000004UL) /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP */ +#define EXC_RETURN_ES (0x00000001UL) /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */ + +/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking */ +#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) /* Value for processors with floating-point extension: */ +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125AUL) /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE */ +#else +#define EXC_INTEGRITY_SIGNATURE (0xFEFA125BUL) /* Value for processors without floating-point extension */ +#endif + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Get Interrupt Target State + \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + \return 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Target State + \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |= ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Clear Interrupt Target State + \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 if interrupt is assigned to Secure + 1 if interrupt is assigned to Non Secure + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL))); + return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + __DSB(); +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief Set Priority Grouping (non-secure) + \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB_NS->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB_NS->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping (non-secure) + \details Reads the priority grouping field from the non-secure NVIC when in secure state. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void) +{ + return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt (non-secure) + \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Interrupt Enable status (non-secure) + \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt (non-secure) + \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Pending Interrupt (non-secure) + \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt (non-secure) + \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt (non-secure) + \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt (non-secure) + \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority (non-secure) + \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every non-secure processor exception. + */ +__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC_NS->IPR[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority (non-secure) + \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} +#endif /* defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_NVICFunctions */ + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv8.h" + +#endif + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + uint32_t mvfr0; + + mvfr0 = FPU->MVFR0; + if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U) + { + return 2U; /* Double + Single precision FPU */ + } + else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U) + { + return 1U; /* Single precision FPU */ + } + else + { + return 0U; /* No FPU */ + } +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ########################## SAU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SAUFunctions SAU Functions + \brief Functions that configure the SAU. + @{ + */ + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) + +/** + \brief Enable SAU + \details Enables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Enable(void) +{ + SAU->CTRL |= (SAU_CTRL_ENABLE_Msk); +} + + + +/** + \brief Disable SAU + \details Disables the Security Attribution Unit (SAU). + */ +__STATIC_INLINE void TZ_SAU_Disable(void) +{ + SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk); +} + +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +/*@} end of CMSIS_Core_SAUFunctions */ + + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) +/** + \brief System Tick Configuration (non-secure) + \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function TZ_SysTick_Config_NS is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick_NS->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick_NS->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick_NS->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} +#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */ + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM35P_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm4.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm4.h new file mode 100644 index 0000000000..12c023b801 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm4.h @@ -0,0 +1,2124 @@ +/**************************************************************************//** + * @file core_cm4.h + * @brief CMSIS Cortex-M4 Core Peripheral Access Layer Header File + * @version V5.1.0 + * @date 13. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM4_H_GENERIC +#define __CORE_CM4_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M4 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM4 definitions */ +#define __CM4_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM4_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM4_CMSIS_VERSION ((__CM4_CMSIS_VERSION_MAIN << 16U) | \ + __CM4_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (4U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions. +*/ +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM4_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM4_H_DEPENDANT +#define __CORE_CM4_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM4_REV + #define __CM4_REV 0x0000U + #warning "__CM4_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M4 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core FPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + +#define APSR_GE_Pos 16U /*!< APSR: GE Position */ +#define APSR_GE_Msk (0xFUL << APSR_GE_Pos) /*!< APSR: GE Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:1; /*!< bit: 9 Reserved */ + uint32_t ICI_IT_1:6; /*!< bit: 10..15 ICI/IT part 1 */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit */ + uint32_t ICI_IT_2:2; /*!< bit: 25..26 ICI/IT part 2 */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_ICI_IT_2_Pos 25U /*!< xPSR: ICI/IT part 2 Position */ +#define xPSR_ICI_IT_2_Msk (3UL << xPSR_ICI_IT_2_Pos) /*!< xPSR: ICI/IT part 2 Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_GE_Pos 16U /*!< xPSR: GE Position */ +#define xPSR_GE_Msk (0xFUL << xPSR_GE_Pos) /*!< xPSR: GE Mask */ + +#define xPSR_ICI_IT_1_Pos 10U /*!< xPSR: ICI/IT part 1 Position */ +#define xPSR_ICI_IT_1_Msk (0x3FUL << xPSR_ICI_IT_1_Pos) /*!< xPSR: ICI/IT part 1 Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t FPCA:1; /*!< bit: 2 FP extension active flag */ + uint32_t _reserved0:29; /*!< bit: 3..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_FPCA_Pos 2U /*!< CONTROL: FPCA Position */ +#define CONTROL_FPCA_Msk (1UL << CONTROL_FPCA_Pos) /*!< CONTROL: FPCA Mask */ + +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[8U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[24U]; + __IOM uint32_t ICER[8U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RESERVED1[24U]; + __IOM uint32_t ISPR[8U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[24U]; + __IOM uint32_t ICPR[8U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[24U]; + __IOM uint32_t IABR[8U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[56U]; + __IOM uint8_t IP[240U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED5[644U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHP[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ISAR[5U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + uint32_t RESERVED0[5U]; + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +#define SCB_AIRCR_VECTRESET_Pos 0U /*!< SCB AIRCR: VECTRESET Position */ +#define SCB_AIRCR_VECTRESET_Msk (1UL /*<< SCB_AIRCR_VECTRESET_Pos*/) /*!< SCB AIRCR: VECTRESET Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +#define SCB_CCR_NONBASETHRDENA_Pos 0U /*!< SCB CCR: NONBASETHRDENA Position */ +#define SCB_CCR_NONBASETHRDENA_Msk (1UL /*<< SCB_CCR_NONBASETHRDENA_Pos*/) /*!< SCB CCR: NONBASETHRDENA Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MLSPERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 5U) /*!< SCB CFSR (MMFSR): MLSPERR Position */ +#define SCB_CFSR_MLSPERR_Msk (1UL << SCB_CFSR_MLSPERR_Pos) /*!< SCB CFSR (MMFSR): MLSPERR Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_LSPERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 5U) /*!< SCB CFSR (BFSR): LSPERR Position */ +#define SCB_CFSR_LSPERR_Msk (1UL << SCB_CFSR_LSPERR_Pos) /*!< SCB CFSR (BFSR): LSPERR Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/* Auxiliary Control Register Definitions */ +#define SCnSCB_ACTLR_DISOOFP_Pos 9U /*!< ACTLR: DISOOFP Position */ +#define SCnSCB_ACTLR_DISOOFP_Msk (1UL << SCnSCB_ACTLR_DISOOFP_Pos) /*!< ACTLR: DISOOFP Mask */ + +#define SCnSCB_ACTLR_DISFPCA_Pos 8U /*!< ACTLR: DISFPCA Position */ +#define SCnSCB_ACTLR_DISFPCA_Msk (1UL << SCnSCB_ACTLR_DISFPCA_Pos) /*!< ACTLR: DISFPCA Mask */ + +#define SCnSCB_ACTLR_DISFOLD_Pos 2U /*!< ACTLR: DISFOLD Position */ +#define SCnSCB_ACTLR_DISFOLD_Msk (1UL << SCnSCB_ACTLR_DISFOLD_Pos) /*!< ACTLR: DISFOLD Mask */ + +#define SCnSCB_ACTLR_DISDEFWBUF_Pos 1U /*!< ACTLR: DISDEFWBUF Position */ +#define SCnSCB_ACTLR_DISDEFWBUF_Msk (1UL << SCnSCB_ACTLR_DISDEFWBUF_Pos) /*!< ACTLR: DISDEFWBUF Mask */ + +#define SCnSCB_ACTLR_DISMCYCINT_Pos 0U /*!< ACTLR: DISMCYCINT Position */ +#define SCnSCB_ACTLR_DISMCYCINT_Msk (1UL /*<< SCnSCB_ACTLR_DISMCYCINT_Pos*/) /*!< ACTLR: DISMCYCINT Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[32U]; + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[6U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TraceBusID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TraceBusID_Msk (0x7FUL << ITM_TCR_TraceBusID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPrescale_Pos 8U /*!< ITM TCR: TSPrescale Position */ +#define ITM_TCR_TSPrescale_Msk (3UL << ITM_TCR_TSPrescale_Pos) /*!< ITM TCR: TSPrescale Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + __IOM uint32_t MASK0; /*!< Offset: 0x024 (R/W) Mask Register 0 */ + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED0[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + __IOM uint32_t MASK1; /*!< Offset: 0x034 (R/W) Mask Register 1 */ + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + __IOM uint32_t MASK2; /*!< Offset: 0x044 (R/W) Mask Register 2 */ + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + __IOM uint32_t MASK3; /*!< Offset: 0x054 (R/W) Mask Register 3 */ + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Mask Register Definitions */ +#define DWT_MASK_MASK_Pos 0U /*!< DWT MASK: MASK Position */ +#define DWT_MASK_MASK_Msk (0x1FUL /*<< DWT_MASK_MASK_Pos*/) /*!< DWT MASK: MASK Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVADDR1_Pos 16U /*!< DWT FUNCTION: DATAVADDR1 Position */ +#define DWT_FUNCTION_DATAVADDR1_Msk (0xFUL << DWT_FUNCTION_DATAVADDR1_Pos) /*!< DWT FUNCTION: DATAVADDR1 Mask */ + +#define DWT_FUNCTION_DATAVADDR0_Pos 12U /*!< DWT FUNCTION: DATAVADDR0 Position */ +#define DWT_FUNCTION_DATAVADDR0_Msk (0xFUL << DWT_FUNCTION_DATAVADDR0_Pos) /*!< DWT FUNCTION: DATAVADDR0 Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_LNK1ENA_Pos 9U /*!< DWT FUNCTION: LNK1ENA Position */ +#define DWT_FUNCTION_LNK1ENA_Msk (0x1UL << DWT_FUNCTION_LNK1ENA_Pos) /*!< DWT FUNCTION: LNK1ENA Mask */ + +#define DWT_FUNCTION_DATAVMATCH_Pos 8U /*!< DWT FUNCTION: DATAVMATCH Position */ +#define DWT_FUNCTION_DATAVMATCH_Msk (0x1UL << DWT_FUNCTION_DATAVMATCH_Pos) /*!< DWT FUNCTION: DATAVMATCH Mask */ + +#define DWT_FUNCTION_CYCMATCH_Pos 7U /*!< DWT FUNCTION: CYCMATCH Position */ +#define DWT_FUNCTION_CYCMATCH_Msk (0x1UL << DWT_FUNCTION_CYCMATCH_Pos) /*!< DWT FUNCTION: CYCMATCH Mask */ + +#define DWT_FUNCTION_EMITRANGE_Pos 5U /*!< DWT FUNCTION: EMITRANGE Position */ +#define DWT_FUNCTION_EMITRANGE_Msk (0x1UL << DWT_FUNCTION_EMITRANGE_Pos) /*!< DWT FUNCTION: EMITRANGE Mask */ + +#define DWT_FUNCTION_FUNCTION_Pos 0U /*!< DWT FUNCTION: FUNCTION Position */ +#define DWT_FUNCTION_FUNCTION_Msk (0xFUL /*<< DWT_FUNCTION_FUNCTION_Pos*/) /*!< DWT FUNCTION: FUNCTION Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IM uint32_t FSCR; /*!< Offset: 0x308 (R/ ) Formatter Synchronization Counter Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER Register */ + __IM uint32_t FIFO0; /*!< Offset: 0xEEC (R/ ) Integration ETM Data */ + __IM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/ ) ITATBCTR2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) ITATBCTR0 */ + __IM uint32_t FIFO1; /*!< Offset: 0xEFC (R/ ) Integration ITM Data */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) TPIU_DEVID */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) TPIU_DEVTYPE */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration ETM Data Register Definitions (FIFO0) */ +#define TPI_FIFO0_ITM_ATVALID_Pos 29U /*!< TPI FIFO0: ITM_ATVALID Position */ +#define TPI_FIFO0_ITM_ATVALID_Msk (0x1UL << TPI_FIFO0_ITM_ATVALID_Pos) /*!< TPI FIFO0: ITM_ATVALID Mask */ + +#define TPI_FIFO0_ITM_bytecount_Pos 27U /*!< TPI FIFO0: ITM_bytecount Position */ +#define TPI_FIFO0_ITM_bytecount_Msk (0x3UL << TPI_FIFO0_ITM_bytecount_Pos) /*!< TPI FIFO0: ITM_bytecount Mask */ + +#define TPI_FIFO0_ETM_ATVALID_Pos 26U /*!< TPI FIFO0: ETM_ATVALID Position */ +#define TPI_FIFO0_ETM_ATVALID_Msk (0x1UL << TPI_FIFO0_ETM_ATVALID_Pos) /*!< TPI FIFO0: ETM_ATVALID Mask */ + +#define TPI_FIFO0_ETM_bytecount_Pos 24U /*!< TPI FIFO0: ETM_bytecount Position */ +#define TPI_FIFO0_ETM_bytecount_Msk (0x3UL << TPI_FIFO0_ETM_bytecount_Pos) /*!< TPI FIFO0: ETM_bytecount Mask */ + +#define TPI_FIFO0_ETM2_Pos 16U /*!< TPI FIFO0: ETM2 Position */ +#define TPI_FIFO0_ETM2_Msk (0xFFUL << TPI_FIFO0_ETM2_Pos) /*!< TPI FIFO0: ETM2 Mask */ + +#define TPI_FIFO0_ETM1_Pos 8U /*!< TPI FIFO0: ETM1 Position */ +#define TPI_FIFO0_ETM1_Msk (0xFFUL << TPI_FIFO0_ETM1_Pos) /*!< TPI FIFO0: ETM1 Mask */ + +#define TPI_FIFO0_ETM0_Pos 0U /*!< TPI FIFO0: ETM0 Position */ +#define TPI_FIFO0_ETM0_Msk (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/) /*!< TPI FIFO0: ETM0 Mask */ + +/* TPI ITATBCTR2 Register Definitions */ +#define TPI_ITATBCTR2_ATREADY2_Pos 0U /*!< TPI ITATBCTR2: ATREADY2 Position */ +#define TPI_ITATBCTR2_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/) /*!< TPI ITATBCTR2: ATREADY2 Mask */ + +#define TPI_ITATBCTR2_ATREADY1_Pos 0U /*!< TPI ITATBCTR2: ATREADY1 Position */ +#define TPI_ITATBCTR2_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/) /*!< TPI ITATBCTR2: ATREADY1 Mask */ + +/* TPI Integration ITM Data Register Definitions (FIFO1) */ +#define TPI_FIFO1_ITM_ATVALID_Pos 29U /*!< TPI FIFO1: ITM_ATVALID Position */ +#define TPI_FIFO1_ITM_ATVALID_Msk (0x1UL << TPI_FIFO1_ITM_ATVALID_Pos) /*!< TPI FIFO1: ITM_ATVALID Mask */ + +#define TPI_FIFO1_ITM_bytecount_Pos 27U /*!< TPI FIFO1: ITM_bytecount Position */ +#define TPI_FIFO1_ITM_bytecount_Msk (0x3UL << TPI_FIFO1_ITM_bytecount_Pos) /*!< TPI FIFO1: ITM_bytecount Mask */ + +#define TPI_FIFO1_ETM_ATVALID_Pos 26U /*!< TPI FIFO1: ETM_ATVALID Position */ +#define TPI_FIFO1_ETM_ATVALID_Msk (0x1UL << TPI_FIFO1_ETM_ATVALID_Pos) /*!< TPI FIFO1: ETM_ATVALID Mask */ + +#define TPI_FIFO1_ETM_bytecount_Pos 24U /*!< TPI FIFO1: ETM_bytecount Position */ +#define TPI_FIFO1_ETM_bytecount_Msk (0x3UL << TPI_FIFO1_ETM_bytecount_Pos) /*!< TPI FIFO1: ETM_bytecount Mask */ + +#define TPI_FIFO1_ITM2_Pos 16U /*!< TPI FIFO1: ITM2 Position */ +#define TPI_FIFO1_ITM2_Msk (0xFFUL << TPI_FIFO1_ITM2_Pos) /*!< TPI FIFO1: ITM2 Mask */ + +#define TPI_FIFO1_ITM1_Pos 8U /*!< TPI FIFO1: ITM1 Position */ +#define TPI_FIFO1_ITM1_Msk (0xFFUL << TPI_FIFO1_ITM1_Pos) /*!< TPI FIFO1: ITM1 Mask */ + +#define TPI_FIFO1_ITM0_Pos 0U /*!< TPI FIFO1: ITM0 Position */ +#define TPI_FIFO1_ITM0_Msk (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/) /*!< TPI FIFO1: ITM0 Mask */ + +/* TPI ITATBCTR0 Register Definitions */ +#define TPI_ITATBCTR0_ATREADY2_Pos 0U /*!< TPI ITATBCTR0: ATREADY2 Position */ +#define TPI_ITATBCTR0_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/) /*!< TPI ITATBCTR0: ATREADY2 Mask */ + +#define TPI_ITATBCTR0_ATREADY1_Pos 0U /*!< TPI ITATBCTR0: ATREADY1 Position */ +#define TPI_ITATBCTR0_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/) /*!< TPI ITATBCTR0: ATREADY1 Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_MinBufSz_Pos 6U /*!< TPI DEVID: MinBufSz Position */ +#define TPI_DEVID_MinBufSz_Msk (0x7UL << TPI_DEVID_MinBufSz_Pos) /*!< TPI DEVID: MinBufSz Mask */ + +#define TPI_DEVID_AsynClkIn_Pos 5U /*!< TPI DEVID: AsynClkIn Position */ +#define TPI_DEVID_AsynClkIn_Msk (0x1UL << TPI_DEVID_AsynClkIn_Pos) /*!< TPI DEVID: AsynClkIn Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region RNRber Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RASR; /*!< Offset: 0x010 (R/W) MPU Region Attribute and Size Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Alias 1 Region Base Address Register */ + __IOM uint32_t RASR_A1; /*!< Offset: 0x018 (R/W) MPU Alias 1 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Alias 2 Region Base Address Register */ + __IOM uint32_t RASR_A2; /*!< Offset: 0x020 (R/W) MPU Alias 2 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Alias 3 Region Base Address Register */ + __IOM uint32_t RASR_A3; /*!< Offset: 0x028 (R/W) MPU Alias 3 Region Attribute and Size Register */ +} MPU_Type; + +#define MPU_TYPE_RALIASES 4U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_ADDR_Pos 5U /*!< MPU RBAR: ADDR Position */ +#define MPU_RBAR_ADDR_Msk (0x7FFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */ + +#define MPU_RBAR_VALID_Pos 4U /*!< MPU RBAR: VALID Position */ +#define MPU_RBAR_VALID_Msk (1UL << MPU_RBAR_VALID_Pos) /*!< MPU RBAR: VALID Mask */ + +#define MPU_RBAR_REGION_Pos 0U /*!< MPU RBAR: REGION Position */ +#define MPU_RBAR_REGION_Msk (0xFUL /*<< MPU_RBAR_REGION_Pos*/) /*!< MPU RBAR: REGION Mask */ + +/* MPU Region Attribute and Size Register Definitions */ +#define MPU_RASR_ATTRS_Pos 16U /*!< MPU RASR: MPU Region Attribute field Position */ +#define MPU_RASR_ATTRS_Msk (0xFFFFUL << MPU_RASR_ATTRS_Pos) /*!< MPU RASR: MPU Region Attribute field Mask */ + +#define MPU_RASR_XN_Pos 28U /*!< MPU RASR: ATTRS.XN Position */ +#define MPU_RASR_XN_Msk (1UL << MPU_RASR_XN_Pos) /*!< MPU RASR: ATTRS.XN Mask */ + +#define MPU_RASR_AP_Pos 24U /*!< MPU RASR: ATTRS.AP Position */ +#define MPU_RASR_AP_Msk (0x7UL << MPU_RASR_AP_Pos) /*!< MPU RASR: ATTRS.AP Mask */ + +#define MPU_RASR_TEX_Pos 19U /*!< MPU RASR: ATTRS.TEX Position */ +#define MPU_RASR_TEX_Msk (0x7UL << MPU_RASR_TEX_Pos) /*!< MPU RASR: ATTRS.TEX Mask */ + +#define MPU_RASR_S_Pos 18U /*!< MPU RASR: ATTRS.S Position */ +#define MPU_RASR_S_Msk (1UL << MPU_RASR_S_Pos) /*!< MPU RASR: ATTRS.S Mask */ + +#define MPU_RASR_C_Pos 17U /*!< MPU RASR: ATTRS.C Position */ +#define MPU_RASR_C_Msk (1UL << MPU_RASR_C_Pos) /*!< MPU RASR: ATTRS.C Mask */ + +#define MPU_RASR_B_Pos 16U /*!< MPU RASR: ATTRS.B Position */ +#define MPU_RASR_B_Msk (1UL << MPU_RASR_B_Pos) /*!< MPU RASR: ATTRS.B Mask */ + +#define MPU_RASR_SRD_Pos 8U /*!< MPU RASR: Sub-Region Disable Position */ +#define MPU_RASR_SRD_Msk (0xFFUL << MPU_RASR_SRD_Pos) /*!< MPU RASR: Sub-Region Disable Mask */ + +#define MPU_RASR_SIZE_Pos 1U /*!< MPU RASR: Region Size Field Position */ +#define MPU_RASR_SIZE_Msk (0x1FUL << MPU_RASR_SIZE_Pos) /*!< MPU RASR: Region Size Field Mask */ + +#define MPU_RASR_ENABLE_Pos 0U /*!< MPU RASR: Region enable bit Position */ +#define MPU_RASR_ENABLE_Msk (1UL /*<< MPU_RASR_ENABLE_Pos*/) /*!< MPU RASR: Region enable bit Disable Mask */ + +/*@} end of group CMSIS_MPU */ +#endif /* defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_FPU Floating Point Unit (FPU) + \brief Type definitions for the Floating Point Unit (FPU) + @{ + */ + +/** + \brief Structure type to access the Floating Point Unit (FPU). + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IOM uint32_t FPCCR; /*!< Offset: 0x004 (R/W) Floating-Point Context Control Register */ + __IOM uint32_t FPCAR; /*!< Offset: 0x008 (R/W) Floating-Point Context Address Register */ + __IOM uint32_t FPDSCR; /*!< Offset: 0x00C (R/W) Floating-Point Default Status Control Register */ + __IM uint32_t MVFR0; /*!< Offset: 0x010 (R/ ) Media and FP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x014 (R/ ) Media and FP Feature Register 1 */ + __IM uint32_t MVFR2; /*!< Offset: 0x018 (R/ ) Media and FP Feature Register 2 */ +} FPU_Type; + +/* Floating-Point Context Control Register Definitions */ +#define FPU_FPCCR_ASPEN_Pos 31U /*!< FPCCR: ASPEN bit Position */ +#define FPU_FPCCR_ASPEN_Msk (1UL << FPU_FPCCR_ASPEN_Pos) /*!< FPCCR: ASPEN bit Mask */ + +#define FPU_FPCCR_LSPEN_Pos 30U /*!< FPCCR: LSPEN Position */ +#define FPU_FPCCR_LSPEN_Msk (1UL << FPU_FPCCR_LSPEN_Pos) /*!< FPCCR: LSPEN bit Mask */ + +#define FPU_FPCCR_MONRDY_Pos 8U /*!< FPCCR: MONRDY Position */ +#define FPU_FPCCR_MONRDY_Msk (1UL << FPU_FPCCR_MONRDY_Pos) /*!< FPCCR: MONRDY bit Mask */ + +#define FPU_FPCCR_BFRDY_Pos 6U /*!< FPCCR: BFRDY Position */ +#define FPU_FPCCR_BFRDY_Msk (1UL << FPU_FPCCR_BFRDY_Pos) /*!< FPCCR: BFRDY bit Mask */ + +#define FPU_FPCCR_MMRDY_Pos 5U /*!< FPCCR: MMRDY Position */ +#define FPU_FPCCR_MMRDY_Msk (1UL << FPU_FPCCR_MMRDY_Pos) /*!< FPCCR: MMRDY bit Mask */ + +#define FPU_FPCCR_HFRDY_Pos 4U /*!< FPCCR: HFRDY Position */ +#define FPU_FPCCR_HFRDY_Msk (1UL << FPU_FPCCR_HFRDY_Pos) /*!< FPCCR: HFRDY bit Mask */ + +#define FPU_FPCCR_THREAD_Pos 3U /*!< FPCCR: processor mode bit Position */ +#define FPU_FPCCR_THREAD_Msk (1UL << FPU_FPCCR_THREAD_Pos) /*!< FPCCR: processor mode active bit Mask */ + +#define FPU_FPCCR_USER_Pos 1U /*!< FPCCR: privilege level bit Position */ +#define FPU_FPCCR_USER_Msk (1UL << FPU_FPCCR_USER_Pos) /*!< FPCCR: privilege level bit Mask */ + +#define FPU_FPCCR_LSPACT_Pos 0U /*!< FPCCR: Lazy state preservation active bit Position */ +#define FPU_FPCCR_LSPACT_Msk (1UL /*<< FPU_FPCCR_LSPACT_Pos*/) /*!< FPCCR: Lazy state preservation active bit Mask */ + +/* Floating-Point Context Address Register Definitions */ +#define FPU_FPCAR_ADDRESS_Pos 3U /*!< FPCAR: ADDRESS bit Position */ +#define FPU_FPCAR_ADDRESS_Msk (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos) /*!< FPCAR: ADDRESS bit Mask */ + +/* Floating-Point Default Status Control Register Definitions */ +#define FPU_FPDSCR_AHP_Pos 26U /*!< FPDSCR: AHP bit Position */ +#define FPU_FPDSCR_AHP_Msk (1UL << FPU_FPDSCR_AHP_Pos) /*!< FPDSCR: AHP bit Mask */ + +#define FPU_FPDSCR_DN_Pos 25U /*!< FPDSCR: DN bit Position */ +#define FPU_FPDSCR_DN_Msk (1UL << FPU_FPDSCR_DN_Pos) /*!< FPDSCR: DN bit Mask */ + +#define FPU_FPDSCR_FZ_Pos 24U /*!< FPDSCR: FZ bit Position */ +#define FPU_FPDSCR_FZ_Msk (1UL << FPU_FPDSCR_FZ_Pos) /*!< FPDSCR: FZ bit Mask */ + +#define FPU_FPDSCR_RMode_Pos 22U /*!< FPDSCR: RMode bit Position */ +#define FPU_FPDSCR_RMode_Msk (3UL << FPU_FPDSCR_RMode_Pos) /*!< FPDSCR: RMode bit Mask */ + +/* Media and FP Feature Register 0 Definitions */ +#define FPU_MVFR0_FP_rounding_modes_Pos 28U /*!< MVFR0: FP rounding modes bits Position */ +#define FPU_MVFR0_FP_rounding_modes_Msk (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos) /*!< MVFR0: FP rounding modes bits Mask */ + +#define FPU_MVFR0_Short_vectors_Pos 24U /*!< MVFR0: Short vectors bits Position */ +#define FPU_MVFR0_Short_vectors_Msk (0xFUL << FPU_MVFR0_Short_vectors_Pos) /*!< MVFR0: Short vectors bits Mask */ + +#define FPU_MVFR0_Square_root_Pos 20U /*!< MVFR0: Square root bits Position */ +#define FPU_MVFR0_Square_root_Msk (0xFUL << FPU_MVFR0_Square_root_Pos) /*!< MVFR0: Square root bits Mask */ + +#define FPU_MVFR0_Divide_Pos 16U /*!< MVFR0: Divide bits Position */ +#define FPU_MVFR0_Divide_Msk (0xFUL << FPU_MVFR0_Divide_Pos) /*!< MVFR0: Divide bits Mask */ + +#define FPU_MVFR0_FP_excep_trapping_Pos 12U /*!< MVFR0: FP exception trapping bits Position */ +#define FPU_MVFR0_FP_excep_trapping_Msk (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos) /*!< MVFR0: FP exception trapping bits Mask */ + +#define FPU_MVFR0_Double_precision_Pos 8U /*!< MVFR0: Double-precision bits Position */ +#define FPU_MVFR0_Double_precision_Msk (0xFUL << FPU_MVFR0_Double_precision_Pos) /*!< MVFR0: Double-precision bits Mask */ + +#define FPU_MVFR0_Single_precision_Pos 4U /*!< MVFR0: Single-precision bits Position */ +#define FPU_MVFR0_Single_precision_Msk (0xFUL << FPU_MVFR0_Single_precision_Pos) /*!< MVFR0: Single-precision bits Mask */ + +#define FPU_MVFR0_A_SIMD_registers_Pos 0U /*!< MVFR0: A_SIMD registers bits Position */ +#define FPU_MVFR0_A_SIMD_registers_Msk (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/) /*!< MVFR0: A_SIMD registers bits Mask */ + +/* Media and FP Feature Register 1 Definitions */ +#define FPU_MVFR1_FP_fused_MAC_Pos 28U /*!< MVFR1: FP fused MAC bits Position */ +#define FPU_MVFR1_FP_fused_MAC_Msk (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos) /*!< MVFR1: FP fused MAC bits Mask */ + +#define FPU_MVFR1_FP_HPFP_Pos 24U /*!< MVFR1: FP HPFP bits Position */ +#define FPU_MVFR1_FP_HPFP_Msk (0xFUL << FPU_MVFR1_FP_HPFP_Pos) /*!< MVFR1: FP HPFP bits Mask */ + +#define FPU_MVFR1_D_NaN_mode_Pos 4U /*!< MVFR1: D_NaN mode bits Position */ +#define FPU_MVFR1_D_NaN_mode_Msk (0xFUL << FPU_MVFR1_D_NaN_mode_Pos) /*!< MVFR1: D_NaN mode bits Mask */ + +#define FPU_MVFR1_FtZ_mode_Pos 0U /*!< MVFR1: FtZ mode bits Position */ +#define FPU_MVFR1_FtZ_mode_Msk (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/) /*!< MVFR1: FtZ mode bits Mask */ + +/* Media and FP Feature Register 2 Definitions */ + +#define FPU_MVFR2_VFP_Misc_Pos 4U /*!< MVFR2: VFP Misc bits Position */ +#define FPU_MVFR2_VFP_Misc_Msk (0xFUL << FPU_MVFR2_VFP_Misc_Pos) /*!< MVFR2: VFP Misc bits Mask */ + +/*@} end of group CMSIS_FPU */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ +#define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ +#define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ +#define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ +#define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ +#define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ +#define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ +#define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE) /*!< Core Debug configuration struct */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ +#endif + +#define FPU_BASE (SCS_BASE + 0x0F30UL) /*!< Floating Point Unit */ +#define FPU ((FPU_Type *) FPU_BASE ) /*!< Floating Point Unit */ + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ +#define EXC_RETURN_HANDLER_FPU (0xFFFFFFE1UL) /* return to Handler mode, uses MSP after return, restore floating-point state */ +#define EXC_RETURN_THREAD_MSP_FPU (0xFFFFFFE9UL) /* return to Thread mode, uses MSP after return, restore floating-point state */ +#define EXC_RETURN_THREAD_PSP_FPU (0xFFFFFFEDUL) /* return to Thread mode, uses PSP after return, restore floating-point state */ + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IP[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector; + /* ARM Application Note 321 states that the M4 does not require the architectural barrier */ +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)); +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv7.h" + +#endif + + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + uint32_t mvfr0; + + mvfr0 = FPU->MVFR0; + if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U) + { + return 1U; /* Single precision FPU */ + } + else + { + return 0U; /* No FPU */ + } +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM4_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm7.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm7.h new file mode 100644 index 0000000000..d1b2f2ca23 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_cm7.h @@ -0,0 +1,2725 @@ +/**************************************************************************//** + * @file core_cm7.h + * @brief CMSIS Cortex-M7 Core Peripheral Access Layer Header File + * @version V5.1.1 + * @date 28. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_CM7_H_GENERIC +#define __CORE_CM7_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup Cortex_M7 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS CM7 definitions */ +#define __CM7_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __CM7_CMSIS_VERSION_SUB ( __CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __CM7_CMSIS_VERSION ((__CM7_CMSIS_VERSION_MAIN << 16U) | \ + __CM7_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_M (7U) /*!< Cortex-M Core */ + +/** __FPU_USED indicates whether an FPU is used or not. + For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions. +*/ +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U) + #define __FPU_USED 1U + #else + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #define __FPU_USED 0U + #endif + #else + #define __FPU_USED 0U + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM7_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM7_H_DEPENDANT +#define __CORE_CM7_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM7_REV + #define __CM7_REV 0x0000U + #warning "__CM7_REV not defined in device header file; using default!" + #endif + + #ifndef __FPU_PRESENT + #define __FPU_PRESENT 0U + #warning "__FPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __ICACHE_PRESENT + #define __ICACHE_PRESENT 0U + #warning "__ICACHE_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __DCACHE_PRESENT + #define __DCACHE_PRESENT 0U + #warning "__DCACHE_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __DTCM_PRESENT + #define __DTCM_PRESENT 0U + #warning "__DTCM_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group Cortex_M7 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + - Core FPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + +#define APSR_GE_Pos 16U /*!< APSR: GE Position */ +#define APSR_GE_Msk (0xFUL << APSR_GE_Pos) /*!< APSR: GE Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:1; /*!< bit: 9 Reserved */ + uint32_t ICI_IT_1:6; /*!< bit: 10..15 ICI/IT part 1 */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit */ + uint32_t ICI_IT_2:2; /*!< bit: 25..26 ICI/IT part 2 */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_ICI_IT_2_Pos 25U /*!< xPSR: ICI/IT part 2 Position */ +#define xPSR_ICI_IT_2_Msk (3UL << xPSR_ICI_IT_2_Pos) /*!< xPSR: ICI/IT part 2 Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_GE_Pos 16U /*!< xPSR: GE Position */ +#define xPSR_GE_Msk (0xFUL << xPSR_GE_Pos) /*!< xPSR: GE Mask */ + +#define xPSR_ICI_IT_1_Pos 10U /*!< xPSR: ICI/IT part 1 Position */ +#define xPSR_ICI_IT_1_Msk (0x3FUL << xPSR_ICI_IT_1_Pos) /*!< xPSR: ICI/IT part 1 Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t FPCA:1; /*!< bit: 2 FP extension active flag */ + uint32_t _reserved0:29; /*!< bit: 3..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_FPCA_Pos 2U /*!< CONTROL: FPCA Position */ +#define CONTROL_FPCA_Msk (1UL << CONTROL_FPCA_Pos) /*!< CONTROL: FPCA Mask */ + +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[8U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[24U]; + __IOM uint32_t ICER[8U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RESERVED1[24U]; + __IOM uint32_t ISPR[8U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[24U]; + __IOM uint32_t ICPR[8U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[24U]; + __IOM uint32_t IABR[8U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[56U]; + __IOM uint8_t IP[240U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED5[644U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHPR[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t ID_PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t ID_DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ID_AFR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t ID_MFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ID_ISAR[5U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + uint32_t RESERVED0[1U]; + __IM uint32_t CLIDR; /*!< Offset: 0x078 (R/ ) Cache Level ID register */ + __IM uint32_t CTR; /*!< Offset: 0x07C (R/ ) Cache Type register */ + __IM uint32_t CCSIDR; /*!< Offset: 0x080 (R/ ) Cache Size ID Register */ + __IOM uint32_t CSSELR; /*!< Offset: 0x084 (R/W) Cache Size Selection Register */ + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ + uint32_t RESERVED3[93U]; + __OM uint32_t STIR; /*!< Offset: 0x200 ( /W) Software Triggered Interrupt Register */ + uint32_t RESERVED4[15U]; + __IM uint32_t MVFR0; /*!< Offset: 0x240 (R/ ) Media and VFP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x244 (R/ ) Media and VFP Feature Register 1 */ + __IM uint32_t MVFR2; /*!< Offset: 0x248 (R/ ) Media and VFP Feature Register 2 */ + uint32_t RESERVED5[1U]; + __OM uint32_t ICIALLU; /*!< Offset: 0x250 ( /W) I-Cache Invalidate All to PoU */ + uint32_t RESERVED6[1U]; + __OM uint32_t ICIMVAU; /*!< Offset: 0x258 ( /W) I-Cache Invalidate by MVA to PoU */ + __OM uint32_t DCIMVAC; /*!< Offset: 0x25C ( /W) D-Cache Invalidate by MVA to PoC */ + __OM uint32_t DCISW; /*!< Offset: 0x260 ( /W) D-Cache Invalidate by Set-way */ + __OM uint32_t DCCMVAU; /*!< Offset: 0x264 ( /W) D-Cache Clean by MVA to PoU */ + __OM uint32_t DCCMVAC; /*!< Offset: 0x268 ( /W) D-Cache Clean by MVA to PoC */ + __OM uint32_t DCCSW; /*!< Offset: 0x26C ( /W) D-Cache Clean by Set-way */ + __OM uint32_t DCCIMVAC; /*!< Offset: 0x270 ( /W) D-Cache Clean and Invalidate by MVA to PoC */ + __OM uint32_t DCCISW; /*!< Offset: 0x274 ( /W) D-Cache Clean and Invalidate by Set-way */ + uint32_t RESERVED7[6U]; + __IOM uint32_t ITCMCR; /*!< Offset: 0x290 (R/W) Instruction Tightly-Coupled Memory Control Register */ + __IOM uint32_t DTCMCR; /*!< Offset: 0x294 (R/W) Data Tightly-Coupled Memory Control Registers */ + __IOM uint32_t AHBPCR; /*!< Offset: 0x298 (R/W) AHBP Control Register */ + __IOM uint32_t CACR; /*!< Offset: 0x29C (R/W) L1 Cache Control Register */ + __IOM uint32_t AHBSCR; /*!< Offset: 0x2A0 (R/W) AHB Slave Control Register */ + uint32_t RESERVED8[1U]; + __IOM uint32_t ABFSR; /*!< Offset: 0x2A8 (R/W) Auxiliary Bus Fault Status Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +#define SCB_AIRCR_VECTRESET_Pos 0U /*!< SCB AIRCR: VECTRESET Position */ +#define SCB_AIRCR_VECTRESET_Msk (1UL /*<< SCB_AIRCR_VECTRESET_Pos*/) /*!< SCB AIRCR: VECTRESET Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_BP_Pos 18U /*!< SCB CCR: Branch prediction enable bit Position */ +#define SCB_CCR_BP_Msk (1UL << SCB_CCR_BP_Pos) /*!< SCB CCR: Branch prediction enable bit Mask */ + +#define SCB_CCR_IC_Pos 17U /*!< SCB CCR: Instruction cache enable bit Position */ +#define SCB_CCR_IC_Msk (1UL << SCB_CCR_IC_Pos) /*!< SCB CCR: Instruction cache enable bit Mask */ + +#define SCB_CCR_DC_Pos 16U /*!< SCB CCR: Cache enable bit Position */ +#define SCB_CCR_DC_Msk (1UL << SCB_CCR_DC_Pos) /*!< SCB CCR: Cache enable bit Mask */ + +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +#define SCB_CCR_NONBASETHRDENA_Pos 0U /*!< SCB CCR: NONBASETHRDENA Position */ +#define SCB_CCR_NONBASETHRDENA_Msk (1UL /*<< SCB_CCR_NONBASETHRDENA_Pos*/) /*!< SCB CCR: NONBASETHRDENA Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MLSPERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 5U) /*!< SCB CFSR (MMFSR): MLSPERR Position */ +#define SCB_CFSR_MLSPERR_Msk (1UL << SCB_CFSR_MLSPERR_Pos) /*!< SCB CFSR (MMFSR): MLSPERR Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_LSPERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 5U) /*!< SCB CFSR (BFSR): LSPERR Position */ +#define SCB_CFSR_LSPERR_Msk (1UL << SCB_CFSR_LSPERR_Pos) /*!< SCB CFSR (BFSR): LSPERR Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/* SCB Cache Level ID Register Definitions */ +#define SCB_CLIDR_LOUU_Pos 27U /*!< SCB CLIDR: LoUU Position */ +#define SCB_CLIDR_LOUU_Msk (7UL << SCB_CLIDR_LOUU_Pos) /*!< SCB CLIDR: LoUU Mask */ + +#define SCB_CLIDR_LOC_Pos 24U /*!< SCB CLIDR: LoC Position */ +#define SCB_CLIDR_LOC_Msk (7UL << SCB_CLIDR_LOC_Pos) /*!< SCB CLIDR: LoC Mask */ + +/* SCB Cache Type Register Definitions */ +#define SCB_CTR_FORMAT_Pos 29U /*!< SCB CTR: Format Position */ +#define SCB_CTR_FORMAT_Msk (7UL << SCB_CTR_FORMAT_Pos) /*!< SCB CTR: Format Mask */ + +#define SCB_CTR_CWG_Pos 24U /*!< SCB CTR: CWG Position */ +#define SCB_CTR_CWG_Msk (0xFUL << SCB_CTR_CWG_Pos) /*!< SCB CTR: CWG Mask */ + +#define SCB_CTR_ERG_Pos 20U /*!< SCB CTR: ERG Position */ +#define SCB_CTR_ERG_Msk (0xFUL << SCB_CTR_ERG_Pos) /*!< SCB CTR: ERG Mask */ + +#define SCB_CTR_DMINLINE_Pos 16U /*!< SCB CTR: DminLine Position */ +#define SCB_CTR_DMINLINE_Msk (0xFUL << SCB_CTR_DMINLINE_Pos) /*!< SCB CTR: DminLine Mask */ + +#define SCB_CTR_IMINLINE_Pos 0U /*!< SCB CTR: ImInLine Position */ +#define SCB_CTR_IMINLINE_Msk (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/) /*!< SCB CTR: ImInLine Mask */ + +/* SCB Cache Size ID Register Definitions */ +#define SCB_CCSIDR_WT_Pos 31U /*!< SCB CCSIDR: WT Position */ +#define SCB_CCSIDR_WT_Msk (1UL << SCB_CCSIDR_WT_Pos) /*!< SCB CCSIDR: WT Mask */ + +#define SCB_CCSIDR_WB_Pos 30U /*!< SCB CCSIDR: WB Position */ +#define SCB_CCSIDR_WB_Msk (1UL << SCB_CCSIDR_WB_Pos) /*!< SCB CCSIDR: WB Mask */ + +#define SCB_CCSIDR_RA_Pos 29U /*!< SCB CCSIDR: RA Position */ +#define SCB_CCSIDR_RA_Msk (1UL << SCB_CCSIDR_RA_Pos) /*!< SCB CCSIDR: RA Mask */ + +#define SCB_CCSIDR_WA_Pos 28U /*!< SCB CCSIDR: WA Position */ +#define SCB_CCSIDR_WA_Msk (1UL << SCB_CCSIDR_WA_Pos) /*!< SCB CCSIDR: WA Mask */ + +#define SCB_CCSIDR_NUMSETS_Pos 13U /*!< SCB CCSIDR: NumSets Position */ +#define SCB_CCSIDR_NUMSETS_Msk (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos) /*!< SCB CCSIDR: NumSets Mask */ + +#define SCB_CCSIDR_ASSOCIATIVITY_Pos 3U /*!< SCB CCSIDR: Associativity Position */ +#define SCB_CCSIDR_ASSOCIATIVITY_Msk (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos) /*!< SCB CCSIDR: Associativity Mask */ + +#define SCB_CCSIDR_LINESIZE_Pos 0U /*!< SCB CCSIDR: LineSize Position */ +#define SCB_CCSIDR_LINESIZE_Msk (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/) /*!< SCB CCSIDR: LineSize Mask */ + +/* SCB Cache Size Selection Register Definitions */ +#define SCB_CSSELR_LEVEL_Pos 1U /*!< SCB CSSELR: Level Position */ +#define SCB_CSSELR_LEVEL_Msk (7UL << SCB_CSSELR_LEVEL_Pos) /*!< SCB CSSELR: Level Mask */ + +#define SCB_CSSELR_IND_Pos 0U /*!< SCB CSSELR: InD Position */ +#define SCB_CSSELR_IND_Msk (1UL /*<< SCB_CSSELR_IND_Pos*/) /*!< SCB CSSELR: InD Mask */ + +/* SCB Software Triggered Interrupt Register Definitions */ +#define SCB_STIR_INTID_Pos 0U /*!< SCB STIR: INTID Position */ +#define SCB_STIR_INTID_Msk (0x1FFUL /*<< SCB_STIR_INTID_Pos*/) /*!< SCB STIR: INTID Mask */ + +/* SCB D-Cache Invalidate by Set-way Register Definitions */ +#define SCB_DCISW_WAY_Pos 30U /*!< SCB DCISW: Way Position */ +#define SCB_DCISW_WAY_Msk (3UL << SCB_DCISW_WAY_Pos) /*!< SCB DCISW: Way Mask */ + +#define SCB_DCISW_SET_Pos 5U /*!< SCB DCISW: Set Position */ +#define SCB_DCISW_SET_Msk (0x1FFUL << SCB_DCISW_SET_Pos) /*!< SCB DCISW: Set Mask */ + +/* SCB D-Cache Clean by Set-way Register Definitions */ +#define SCB_DCCSW_WAY_Pos 30U /*!< SCB DCCSW: Way Position */ +#define SCB_DCCSW_WAY_Msk (3UL << SCB_DCCSW_WAY_Pos) /*!< SCB DCCSW: Way Mask */ + +#define SCB_DCCSW_SET_Pos 5U /*!< SCB DCCSW: Set Position */ +#define SCB_DCCSW_SET_Msk (0x1FFUL << SCB_DCCSW_SET_Pos) /*!< SCB DCCSW: Set Mask */ + +/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */ +#define SCB_DCCISW_WAY_Pos 30U /*!< SCB DCCISW: Way Position */ +#define SCB_DCCISW_WAY_Msk (3UL << SCB_DCCISW_WAY_Pos) /*!< SCB DCCISW: Way Mask */ + +#define SCB_DCCISW_SET_Pos 5U /*!< SCB DCCISW: Set Position */ +#define SCB_DCCISW_SET_Msk (0x1FFUL << SCB_DCCISW_SET_Pos) /*!< SCB DCCISW: Set Mask */ + +/* Instruction Tightly-Coupled Memory Control Register Definitions */ +#define SCB_ITCMCR_SZ_Pos 3U /*!< SCB ITCMCR: SZ Position */ +#define SCB_ITCMCR_SZ_Msk (0xFUL << SCB_ITCMCR_SZ_Pos) /*!< SCB ITCMCR: SZ Mask */ + +#define SCB_ITCMCR_RETEN_Pos 2U /*!< SCB ITCMCR: RETEN Position */ +#define SCB_ITCMCR_RETEN_Msk (1UL << SCB_ITCMCR_RETEN_Pos) /*!< SCB ITCMCR: RETEN Mask */ + +#define SCB_ITCMCR_RMW_Pos 1U /*!< SCB ITCMCR: RMW Position */ +#define SCB_ITCMCR_RMW_Msk (1UL << SCB_ITCMCR_RMW_Pos) /*!< SCB ITCMCR: RMW Mask */ + +#define SCB_ITCMCR_EN_Pos 0U /*!< SCB ITCMCR: EN Position */ +#define SCB_ITCMCR_EN_Msk (1UL /*<< SCB_ITCMCR_EN_Pos*/) /*!< SCB ITCMCR: EN Mask */ + +/* Data Tightly-Coupled Memory Control Register Definitions */ +#define SCB_DTCMCR_SZ_Pos 3U /*!< SCB DTCMCR: SZ Position */ +#define SCB_DTCMCR_SZ_Msk (0xFUL << SCB_DTCMCR_SZ_Pos) /*!< SCB DTCMCR: SZ Mask */ + +#define SCB_DTCMCR_RETEN_Pos 2U /*!< SCB DTCMCR: RETEN Position */ +#define SCB_DTCMCR_RETEN_Msk (1UL << SCB_DTCMCR_RETEN_Pos) /*!< SCB DTCMCR: RETEN Mask */ + +#define SCB_DTCMCR_RMW_Pos 1U /*!< SCB DTCMCR: RMW Position */ +#define SCB_DTCMCR_RMW_Msk (1UL << SCB_DTCMCR_RMW_Pos) /*!< SCB DTCMCR: RMW Mask */ + +#define SCB_DTCMCR_EN_Pos 0U /*!< SCB DTCMCR: EN Position */ +#define SCB_DTCMCR_EN_Msk (1UL /*<< SCB_DTCMCR_EN_Pos*/) /*!< SCB DTCMCR: EN Mask */ + +/* AHBP Control Register Definitions */ +#define SCB_AHBPCR_SZ_Pos 1U /*!< SCB AHBPCR: SZ Position */ +#define SCB_AHBPCR_SZ_Msk (7UL << SCB_AHBPCR_SZ_Pos) /*!< SCB AHBPCR: SZ Mask */ + +#define SCB_AHBPCR_EN_Pos 0U /*!< SCB AHBPCR: EN Position */ +#define SCB_AHBPCR_EN_Msk (1UL /*<< SCB_AHBPCR_EN_Pos*/) /*!< SCB AHBPCR: EN Mask */ + +/* L1 Cache Control Register Definitions */ +#define SCB_CACR_FORCEWT_Pos 2U /*!< SCB CACR: FORCEWT Position */ +#define SCB_CACR_FORCEWT_Msk (1UL << SCB_CACR_FORCEWT_Pos) /*!< SCB CACR: FORCEWT Mask */ + +#define SCB_CACR_ECCEN_Pos 1U /*!< SCB CACR: ECCEN Position */ +#define SCB_CACR_ECCEN_Msk (1UL << SCB_CACR_ECCEN_Pos) /*!< SCB CACR: ECCEN Mask */ + +#define SCB_CACR_SIWT_Pos 0U /*!< SCB CACR: SIWT Position */ +#define SCB_CACR_SIWT_Msk (1UL /*<< SCB_CACR_SIWT_Pos*/) /*!< SCB CACR: SIWT Mask */ + +/* AHBS Control Register Definitions */ +#define SCB_AHBSCR_INITCOUNT_Pos 11U /*!< SCB AHBSCR: INITCOUNT Position */ +#define SCB_AHBSCR_INITCOUNT_Msk (0x1FUL << SCB_AHBPCR_INITCOUNT_Pos) /*!< SCB AHBSCR: INITCOUNT Mask */ + +#define SCB_AHBSCR_TPRI_Pos 2U /*!< SCB AHBSCR: TPRI Position */ +#define SCB_AHBSCR_TPRI_Msk (0x1FFUL << SCB_AHBPCR_TPRI_Pos) /*!< SCB AHBSCR: TPRI Mask */ + +#define SCB_AHBSCR_CTL_Pos 0U /*!< SCB AHBSCR: CTL Position*/ +#define SCB_AHBSCR_CTL_Msk (3UL /*<< SCB_AHBPCR_CTL_Pos*/) /*!< SCB AHBSCR: CTL Mask */ + +/* Auxiliary Bus Fault Status Register Definitions */ +#define SCB_ABFSR_AXIMTYPE_Pos 8U /*!< SCB ABFSR: AXIMTYPE Position*/ +#define SCB_ABFSR_AXIMTYPE_Msk (3UL << SCB_ABFSR_AXIMTYPE_Pos) /*!< SCB ABFSR: AXIMTYPE Mask */ + +#define SCB_ABFSR_EPPB_Pos 4U /*!< SCB ABFSR: EPPB Position*/ +#define SCB_ABFSR_EPPB_Msk (1UL << SCB_ABFSR_EPPB_Pos) /*!< SCB ABFSR: EPPB Mask */ + +#define SCB_ABFSR_AXIM_Pos 3U /*!< SCB ABFSR: AXIM Position*/ +#define SCB_ABFSR_AXIM_Msk (1UL << SCB_ABFSR_AXIM_Pos) /*!< SCB ABFSR: AXIM Mask */ + +#define SCB_ABFSR_AHBP_Pos 2U /*!< SCB ABFSR: AHBP Position*/ +#define SCB_ABFSR_AHBP_Msk (1UL << SCB_ABFSR_AHBP_Pos) /*!< SCB ABFSR: AHBP Mask */ + +#define SCB_ABFSR_DTCM_Pos 1U /*!< SCB ABFSR: DTCM Position*/ +#define SCB_ABFSR_DTCM_Msk (1UL << SCB_ABFSR_DTCM_Pos) /*!< SCB ABFSR: DTCM Mask */ + +#define SCB_ABFSR_ITCM_Pos 0U /*!< SCB ABFSR: ITCM Position*/ +#define SCB_ABFSR_ITCM_Msk (1UL /*<< SCB_ABFSR_ITCM_Pos*/) /*!< SCB ABFSR: ITCM Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/* Auxiliary Control Register Definitions */ +#define SCnSCB_ACTLR_DISDYNADD_Pos 26U /*!< ACTLR: DISDYNADD Position */ +#define SCnSCB_ACTLR_DISDYNADD_Msk (1UL << SCnSCB_ACTLR_DISDYNADD_Pos) /*!< ACTLR: DISDYNADD Mask */ + +#define SCnSCB_ACTLR_DISISSCH1_Pos 21U /*!< ACTLR: DISISSCH1 Position */ +#define SCnSCB_ACTLR_DISISSCH1_Msk (0x1FUL << SCnSCB_ACTLR_DISISSCH1_Pos) /*!< ACTLR: DISISSCH1 Mask */ + +#define SCnSCB_ACTLR_DISDI_Pos 16U /*!< ACTLR: DISDI Position */ +#define SCnSCB_ACTLR_DISDI_Msk (0x1FUL << SCnSCB_ACTLR_DISDI_Pos) /*!< ACTLR: DISDI Mask */ + +#define SCnSCB_ACTLR_DISCRITAXIRUR_Pos 15U /*!< ACTLR: DISCRITAXIRUR Position */ +#define SCnSCB_ACTLR_DISCRITAXIRUR_Msk (1UL << SCnSCB_ACTLR_DISCRITAXIRUR_Pos) /*!< ACTLR: DISCRITAXIRUR Mask */ + +#define SCnSCB_ACTLR_DISBTACALLOC_Pos 14U /*!< ACTLR: DISBTACALLOC Position */ +#define SCnSCB_ACTLR_DISBTACALLOC_Msk (1UL << SCnSCB_ACTLR_DISBTACALLOC_Pos) /*!< ACTLR: DISBTACALLOC Mask */ + +#define SCnSCB_ACTLR_DISBTACREAD_Pos 13U /*!< ACTLR: DISBTACREAD Position */ +#define SCnSCB_ACTLR_DISBTACREAD_Msk (1UL << SCnSCB_ACTLR_DISBTACREAD_Pos) /*!< ACTLR: DISBTACREAD Mask */ + +#define SCnSCB_ACTLR_DISITMATBFLUSH_Pos 12U /*!< ACTLR: DISITMATBFLUSH Position */ +#define SCnSCB_ACTLR_DISITMATBFLUSH_Msk (1UL << SCnSCB_ACTLR_DISITMATBFLUSH_Pos) /*!< ACTLR: DISITMATBFLUSH Mask */ + +#define SCnSCB_ACTLR_DISRAMODE_Pos 11U /*!< ACTLR: DISRAMODE Position */ +#define SCnSCB_ACTLR_DISRAMODE_Msk (1UL << SCnSCB_ACTLR_DISRAMODE_Pos) /*!< ACTLR: DISRAMODE Mask */ + +#define SCnSCB_ACTLR_FPEXCODIS_Pos 10U /*!< ACTLR: FPEXCODIS Position */ +#define SCnSCB_ACTLR_FPEXCODIS_Msk (1UL << SCnSCB_ACTLR_FPEXCODIS_Pos) /*!< ACTLR: FPEXCODIS Mask */ + +#define SCnSCB_ACTLR_DISFOLD_Pos 2U /*!< ACTLR: DISFOLD Position */ +#define SCnSCB_ACTLR_DISFOLD_Msk (1UL << SCnSCB_ACTLR_DISFOLD_Pos) /*!< ACTLR: DISFOLD Mask */ + +#define SCnSCB_ACTLR_DISMCYCINT_Pos 0U /*!< ACTLR: DISMCYCINT Position */ +#define SCnSCB_ACTLR_DISMCYCINT_Msk (1UL /*<< SCnSCB_ACTLR_DISMCYCINT_Pos*/) /*!< ACTLR: DISMCYCINT Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[32U]; + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[6U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TraceBusID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TraceBusID_Msk (0x7FUL << ITM_TCR_TraceBusID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPrescale_Pos 8U /*!< ITM TCR: TSPrescale Position */ +#define ITM_TCR_TSPrescale_Msk (3UL << ITM_TCR_TSPrescale_Pos) /*!< ITM TCR: TSPrescale Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + __IOM uint32_t MASK0; /*!< Offset: 0x024 (R/W) Mask Register 0 */ + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED0[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + __IOM uint32_t MASK1; /*!< Offset: 0x034 (R/W) Mask Register 1 */ + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + __IOM uint32_t MASK2; /*!< Offset: 0x044 (R/W) Mask Register 2 */ + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + __IOM uint32_t MASK3; /*!< Offset: 0x054 (R/W) Mask Register 3 */ + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ + uint32_t RESERVED3[981U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( W) Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R ) Lock Status Register */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Mask Register Definitions */ +#define DWT_MASK_MASK_Pos 0U /*!< DWT MASK: MASK Position */ +#define DWT_MASK_MASK_Msk (0x1FUL /*<< DWT_MASK_MASK_Pos*/) /*!< DWT MASK: MASK Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVADDR1_Pos 16U /*!< DWT FUNCTION: DATAVADDR1 Position */ +#define DWT_FUNCTION_DATAVADDR1_Msk (0xFUL << DWT_FUNCTION_DATAVADDR1_Pos) /*!< DWT FUNCTION: DATAVADDR1 Mask */ + +#define DWT_FUNCTION_DATAVADDR0_Pos 12U /*!< DWT FUNCTION: DATAVADDR0 Position */ +#define DWT_FUNCTION_DATAVADDR0_Msk (0xFUL << DWT_FUNCTION_DATAVADDR0_Pos) /*!< DWT FUNCTION: DATAVADDR0 Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_LNK1ENA_Pos 9U /*!< DWT FUNCTION: LNK1ENA Position */ +#define DWT_FUNCTION_LNK1ENA_Msk (0x1UL << DWT_FUNCTION_LNK1ENA_Pos) /*!< DWT FUNCTION: LNK1ENA Mask */ + +#define DWT_FUNCTION_DATAVMATCH_Pos 8U /*!< DWT FUNCTION: DATAVMATCH Position */ +#define DWT_FUNCTION_DATAVMATCH_Msk (0x1UL << DWT_FUNCTION_DATAVMATCH_Pos) /*!< DWT FUNCTION: DATAVMATCH Mask */ + +#define DWT_FUNCTION_CYCMATCH_Pos 7U /*!< DWT FUNCTION: CYCMATCH Position */ +#define DWT_FUNCTION_CYCMATCH_Msk (0x1UL << DWT_FUNCTION_CYCMATCH_Pos) /*!< DWT FUNCTION: CYCMATCH Mask */ + +#define DWT_FUNCTION_EMITRANGE_Pos 5U /*!< DWT FUNCTION: EMITRANGE Position */ +#define DWT_FUNCTION_EMITRANGE_Msk (0x1UL << DWT_FUNCTION_EMITRANGE_Pos) /*!< DWT FUNCTION: EMITRANGE Mask */ + +#define DWT_FUNCTION_FUNCTION_Pos 0U /*!< DWT FUNCTION: FUNCTION Position */ +#define DWT_FUNCTION_FUNCTION_Msk (0xFUL /*<< DWT_FUNCTION_FUNCTION_Pos*/) /*!< DWT FUNCTION: FUNCTION Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IM uint32_t FSCR; /*!< Offset: 0x308 (R/ ) Formatter Synchronization Counter Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER Register */ + __IM uint32_t FIFO0; /*!< Offset: 0xEEC (R/ ) Integration ETM Data */ + __IM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/ ) ITATBCTR2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) ITATBCTR0 */ + __IM uint32_t FIFO1; /*!< Offset: 0xEFC (R/ ) Integration ITM Data */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) TPIU_DEVID */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) TPIU_DEVTYPE */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration ETM Data Register Definitions (FIFO0) */ +#define TPI_FIFO0_ITM_ATVALID_Pos 29U /*!< TPI FIFO0: ITM_ATVALID Position */ +#define TPI_FIFO0_ITM_ATVALID_Msk (0x1UL << TPI_FIFO0_ITM_ATVALID_Pos) /*!< TPI FIFO0: ITM_ATVALID Mask */ + +#define TPI_FIFO0_ITM_bytecount_Pos 27U /*!< TPI FIFO0: ITM_bytecount Position */ +#define TPI_FIFO0_ITM_bytecount_Msk (0x3UL << TPI_FIFO0_ITM_bytecount_Pos) /*!< TPI FIFO0: ITM_bytecount Mask */ + +#define TPI_FIFO0_ETM_ATVALID_Pos 26U /*!< TPI FIFO0: ETM_ATVALID Position */ +#define TPI_FIFO0_ETM_ATVALID_Msk (0x1UL << TPI_FIFO0_ETM_ATVALID_Pos) /*!< TPI FIFO0: ETM_ATVALID Mask */ + +#define TPI_FIFO0_ETM_bytecount_Pos 24U /*!< TPI FIFO0: ETM_bytecount Position */ +#define TPI_FIFO0_ETM_bytecount_Msk (0x3UL << TPI_FIFO0_ETM_bytecount_Pos) /*!< TPI FIFO0: ETM_bytecount Mask */ + +#define TPI_FIFO0_ETM2_Pos 16U /*!< TPI FIFO0: ETM2 Position */ +#define TPI_FIFO0_ETM2_Msk (0xFFUL << TPI_FIFO0_ETM2_Pos) /*!< TPI FIFO0: ETM2 Mask */ + +#define TPI_FIFO0_ETM1_Pos 8U /*!< TPI FIFO0: ETM1 Position */ +#define TPI_FIFO0_ETM1_Msk (0xFFUL << TPI_FIFO0_ETM1_Pos) /*!< TPI FIFO0: ETM1 Mask */ + +#define TPI_FIFO0_ETM0_Pos 0U /*!< TPI FIFO0: ETM0 Position */ +#define TPI_FIFO0_ETM0_Msk (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/) /*!< TPI FIFO0: ETM0 Mask */ + +/* TPI ITATBCTR2 Register Definitions */ +#define TPI_ITATBCTR2_ATREADY2_Pos 0U /*!< TPI ITATBCTR2: ATREADY2 Position */ +#define TPI_ITATBCTR2_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/) /*!< TPI ITATBCTR2: ATREADY2 Mask */ + +#define TPI_ITATBCTR2_ATREADY1_Pos 0U /*!< TPI ITATBCTR2: ATREADY1 Position */ +#define TPI_ITATBCTR2_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/) /*!< TPI ITATBCTR2: ATREADY1 Mask */ + +/* TPI Integration ITM Data Register Definitions (FIFO1) */ +#define TPI_FIFO1_ITM_ATVALID_Pos 29U /*!< TPI FIFO1: ITM_ATVALID Position */ +#define TPI_FIFO1_ITM_ATVALID_Msk (0x1UL << TPI_FIFO1_ITM_ATVALID_Pos) /*!< TPI FIFO1: ITM_ATVALID Mask */ + +#define TPI_FIFO1_ITM_bytecount_Pos 27U /*!< TPI FIFO1: ITM_bytecount Position */ +#define TPI_FIFO1_ITM_bytecount_Msk (0x3UL << TPI_FIFO1_ITM_bytecount_Pos) /*!< TPI FIFO1: ITM_bytecount Mask */ + +#define TPI_FIFO1_ETM_ATVALID_Pos 26U /*!< TPI FIFO1: ETM_ATVALID Position */ +#define TPI_FIFO1_ETM_ATVALID_Msk (0x1UL << TPI_FIFO1_ETM_ATVALID_Pos) /*!< TPI FIFO1: ETM_ATVALID Mask */ + +#define TPI_FIFO1_ETM_bytecount_Pos 24U /*!< TPI FIFO1: ETM_bytecount Position */ +#define TPI_FIFO1_ETM_bytecount_Msk (0x3UL << TPI_FIFO1_ETM_bytecount_Pos) /*!< TPI FIFO1: ETM_bytecount Mask */ + +#define TPI_FIFO1_ITM2_Pos 16U /*!< TPI FIFO1: ITM2 Position */ +#define TPI_FIFO1_ITM2_Msk (0xFFUL << TPI_FIFO1_ITM2_Pos) /*!< TPI FIFO1: ITM2 Mask */ + +#define TPI_FIFO1_ITM1_Pos 8U /*!< TPI FIFO1: ITM1 Position */ +#define TPI_FIFO1_ITM1_Msk (0xFFUL << TPI_FIFO1_ITM1_Pos) /*!< TPI FIFO1: ITM1 Mask */ + +#define TPI_FIFO1_ITM0_Pos 0U /*!< TPI FIFO1: ITM0 Position */ +#define TPI_FIFO1_ITM0_Msk (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/) /*!< TPI FIFO1: ITM0 Mask */ + +/* TPI ITATBCTR0 Register Definitions */ +#define TPI_ITATBCTR0_ATREADY2_Pos 0U /*!< TPI ITATBCTR0: ATREADY2 Position */ +#define TPI_ITATBCTR0_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/) /*!< TPI ITATBCTR0: ATREADY2 Mask */ + +#define TPI_ITATBCTR0_ATREADY1_Pos 0U /*!< TPI ITATBCTR0: ATREADY1 Position */ +#define TPI_ITATBCTR0_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/) /*!< TPI ITATBCTR0: ATREADY1 Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_MinBufSz_Pos 6U /*!< TPI DEVID: MinBufSz Position */ +#define TPI_DEVID_MinBufSz_Msk (0x7UL << TPI_DEVID_MinBufSz_Pos) /*!< TPI DEVID: MinBufSz Mask */ + +#define TPI_DEVID_AsynClkIn_Pos 5U /*!< TPI DEVID: AsynClkIn Position */ +#define TPI_DEVID_AsynClkIn_Msk (0x1UL << TPI_DEVID_AsynClkIn_Pos) /*!< TPI DEVID: AsynClkIn Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region RNRber Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RASR; /*!< Offset: 0x010 (R/W) MPU Region Attribute and Size Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Alias 1 Region Base Address Register */ + __IOM uint32_t RASR_A1; /*!< Offset: 0x018 (R/W) MPU Alias 1 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Alias 2 Region Base Address Register */ + __IOM uint32_t RASR_A2; /*!< Offset: 0x020 (R/W) MPU Alias 2 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Alias 3 Region Base Address Register */ + __IOM uint32_t RASR_A3; /*!< Offset: 0x028 (R/W) MPU Alias 3 Region Attribute and Size Register */ +} MPU_Type; + +#define MPU_TYPE_RALIASES 4U + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_ADDR_Pos 5U /*!< MPU RBAR: ADDR Position */ +#define MPU_RBAR_ADDR_Msk (0x7FFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */ + +#define MPU_RBAR_VALID_Pos 4U /*!< MPU RBAR: VALID Position */ +#define MPU_RBAR_VALID_Msk (1UL << MPU_RBAR_VALID_Pos) /*!< MPU RBAR: VALID Mask */ + +#define MPU_RBAR_REGION_Pos 0U /*!< MPU RBAR: REGION Position */ +#define MPU_RBAR_REGION_Msk (0xFUL /*<< MPU_RBAR_REGION_Pos*/) /*!< MPU RBAR: REGION Mask */ + +/* MPU Region Attribute and Size Register Definitions */ +#define MPU_RASR_ATTRS_Pos 16U /*!< MPU RASR: MPU Region Attribute field Position */ +#define MPU_RASR_ATTRS_Msk (0xFFFFUL << MPU_RASR_ATTRS_Pos) /*!< MPU RASR: MPU Region Attribute field Mask */ + +#define MPU_RASR_XN_Pos 28U /*!< MPU RASR: ATTRS.XN Position */ +#define MPU_RASR_XN_Msk (1UL << MPU_RASR_XN_Pos) /*!< MPU RASR: ATTRS.XN Mask */ + +#define MPU_RASR_AP_Pos 24U /*!< MPU RASR: ATTRS.AP Position */ +#define MPU_RASR_AP_Msk (0x7UL << MPU_RASR_AP_Pos) /*!< MPU RASR: ATTRS.AP Mask */ + +#define MPU_RASR_TEX_Pos 19U /*!< MPU RASR: ATTRS.TEX Position */ +#define MPU_RASR_TEX_Msk (0x7UL << MPU_RASR_TEX_Pos) /*!< MPU RASR: ATTRS.TEX Mask */ + +#define MPU_RASR_S_Pos 18U /*!< MPU RASR: ATTRS.S Position */ +#define MPU_RASR_S_Msk (1UL << MPU_RASR_S_Pos) /*!< MPU RASR: ATTRS.S Mask */ + +#define MPU_RASR_C_Pos 17U /*!< MPU RASR: ATTRS.C Position */ +#define MPU_RASR_C_Msk (1UL << MPU_RASR_C_Pos) /*!< MPU RASR: ATTRS.C Mask */ + +#define MPU_RASR_B_Pos 16U /*!< MPU RASR: ATTRS.B Position */ +#define MPU_RASR_B_Msk (1UL << MPU_RASR_B_Pos) /*!< MPU RASR: ATTRS.B Mask */ + +#define MPU_RASR_SRD_Pos 8U /*!< MPU RASR: Sub-Region Disable Position */ +#define MPU_RASR_SRD_Msk (0xFFUL << MPU_RASR_SRD_Pos) /*!< MPU RASR: Sub-Region Disable Mask */ + +#define MPU_RASR_SIZE_Pos 1U /*!< MPU RASR: Region Size Field Position */ +#define MPU_RASR_SIZE_Msk (0x1FUL << MPU_RASR_SIZE_Pos) /*!< MPU RASR: Region Size Field Mask */ + +#define MPU_RASR_ENABLE_Pos 0U /*!< MPU RASR: Region enable bit Position */ +#define MPU_RASR_ENABLE_Msk (1UL /*<< MPU_RASR_ENABLE_Pos*/) /*!< MPU RASR: Region enable bit Disable Mask */ + +/*@} end of group CMSIS_MPU */ +#endif /* defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_FPU Floating Point Unit (FPU) + \brief Type definitions for the Floating Point Unit (FPU) + @{ + */ + +/** + \brief Structure type to access the Floating Point Unit (FPU). + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IOM uint32_t FPCCR; /*!< Offset: 0x004 (R/W) Floating-Point Context Control Register */ + __IOM uint32_t FPCAR; /*!< Offset: 0x008 (R/W) Floating-Point Context Address Register */ + __IOM uint32_t FPDSCR; /*!< Offset: 0x00C (R/W) Floating-Point Default Status Control Register */ + __IM uint32_t MVFR0; /*!< Offset: 0x010 (R/ ) Media and FP Feature Register 0 */ + __IM uint32_t MVFR1; /*!< Offset: 0x014 (R/ ) Media and FP Feature Register 1 */ + __IM uint32_t MVFR2; /*!< Offset: 0x018 (R/ ) Media and FP Feature Register 2 */ +} FPU_Type; + +/* Floating-Point Context Control Register Definitions */ +#define FPU_FPCCR_ASPEN_Pos 31U /*!< FPCCR: ASPEN bit Position */ +#define FPU_FPCCR_ASPEN_Msk (1UL << FPU_FPCCR_ASPEN_Pos) /*!< FPCCR: ASPEN bit Mask */ + +#define FPU_FPCCR_LSPEN_Pos 30U /*!< FPCCR: LSPEN Position */ +#define FPU_FPCCR_LSPEN_Msk (1UL << FPU_FPCCR_LSPEN_Pos) /*!< FPCCR: LSPEN bit Mask */ + +#define FPU_FPCCR_MONRDY_Pos 8U /*!< FPCCR: MONRDY Position */ +#define FPU_FPCCR_MONRDY_Msk (1UL << FPU_FPCCR_MONRDY_Pos) /*!< FPCCR: MONRDY bit Mask */ + +#define FPU_FPCCR_BFRDY_Pos 6U /*!< FPCCR: BFRDY Position */ +#define FPU_FPCCR_BFRDY_Msk (1UL << FPU_FPCCR_BFRDY_Pos) /*!< FPCCR: BFRDY bit Mask */ + +#define FPU_FPCCR_MMRDY_Pos 5U /*!< FPCCR: MMRDY Position */ +#define FPU_FPCCR_MMRDY_Msk (1UL << FPU_FPCCR_MMRDY_Pos) /*!< FPCCR: MMRDY bit Mask */ + +#define FPU_FPCCR_HFRDY_Pos 4U /*!< FPCCR: HFRDY Position */ +#define FPU_FPCCR_HFRDY_Msk (1UL << FPU_FPCCR_HFRDY_Pos) /*!< FPCCR: HFRDY bit Mask */ + +#define FPU_FPCCR_THREAD_Pos 3U /*!< FPCCR: processor mode bit Position */ +#define FPU_FPCCR_THREAD_Msk (1UL << FPU_FPCCR_THREAD_Pos) /*!< FPCCR: processor mode active bit Mask */ + +#define FPU_FPCCR_USER_Pos 1U /*!< FPCCR: privilege level bit Position */ +#define FPU_FPCCR_USER_Msk (1UL << FPU_FPCCR_USER_Pos) /*!< FPCCR: privilege level bit Mask */ + +#define FPU_FPCCR_LSPACT_Pos 0U /*!< FPCCR: Lazy state preservation active bit Position */ +#define FPU_FPCCR_LSPACT_Msk (1UL /*<< FPU_FPCCR_LSPACT_Pos*/) /*!< FPCCR: Lazy state preservation active bit Mask */ + +/* Floating-Point Context Address Register Definitions */ +#define FPU_FPCAR_ADDRESS_Pos 3U /*!< FPCAR: ADDRESS bit Position */ +#define FPU_FPCAR_ADDRESS_Msk (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos) /*!< FPCAR: ADDRESS bit Mask */ + +/* Floating-Point Default Status Control Register Definitions */ +#define FPU_FPDSCR_AHP_Pos 26U /*!< FPDSCR: AHP bit Position */ +#define FPU_FPDSCR_AHP_Msk (1UL << FPU_FPDSCR_AHP_Pos) /*!< FPDSCR: AHP bit Mask */ + +#define FPU_FPDSCR_DN_Pos 25U /*!< FPDSCR: DN bit Position */ +#define FPU_FPDSCR_DN_Msk (1UL << FPU_FPDSCR_DN_Pos) /*!< FPDSCR: DN bit Mask */ + +#define FPU_FPDSCR_FZ_Pos 24U /*!< FPDSCR: FZ bit Position */ +#define FPU_FPDSCR_FZ_Msk (1UL << FPU_FPDSCR_FZ_Pos) /*!< FPDSCR: FZ bit Mask */ + +#define FPU_FPDSCR_RMode_Pos 22U /*!< FPDSCR: RMode bit Position */ +#define FPU_FPDSCR_RMode_Msk (3UL << FPU_FPDSCR_RMode_Pos) /*!< FPDSCR: RMode bit Mask */ + +/* Media and FP Feature Register 0 Definitions */ +#define FPU_MVFR0_FP_rounding_modes_Pos 28U /*!< MVFR0: FP rounding modes bits Position */ +#define FPU_MVFR0_FP_rounding_modes_Msk (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos) /*!< MVFR0: FP rounding modes bits Mask */ + +#define FPU_MVFR0_Short_vectors_Pos 24U /*!< MVFR0: Short vectors bits Position */ +#define FPU_MVFR0_Short_vectors_Msk (0xFUL << FPU_MVFR0_Short_vectors_Pos) /*!< MVFR0: Short vectors bits Mask */ + +#define FPU_MVFR0_Square_root_Pos 20U /*!< MVFR0: Square root bits Position */ +#define FPU_MVFR0_Square_root_Msk (0xFUL << FPU_MVFR0_Square_root_Pos) /*!< MVFR0: Square root bits Mask */ + +#define FPU_MVFR0_Divide_Pos 16U /*!< MVFR0: Divide bits Position */ +#define FPU_MVFR0_Divide_Msk (0xFUL << FPU_MVFR0_Divide_Pos) /*!< MVFR0: Divide bits Mask */ + +#define FPU_MVFR0_FP_excep_trapping_Pos 12U /*!< MVFR0: FP exception trapping bits Position */ +#define FPU_MVFR0_FP_excep_trapping_Msk (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos) /*!< MVFR0: FP exception trapping bits Mask */ + +#define FPU_MVFR0_Double_precision_Pos 8U /*!< MVFR0: Double-precision bits Position */ +#define FPU_MVFR0_Double_precision_Msk (0xFUL << FPU_MVFR0_Double_precision_Pos) /*!< MVFR0: Double-precision bits Mask */ + +#define FPU_MVFR0_Single_precision_Pos 4U /*!< MVFR0: Single-precision bits Position */ +#define FPU_MVFR0_Single_precision_Msk (0xFUL << FPU_MVFR0_Single_precision_Pos) /*!< MVFR0: Single-precision bits Mask */ + +#define FPU_MVFR0_A_SIMD_registers_Pos 0U /*!< MVFR0: A_SIMD registers bits Position */ +#define FPU_MVFR0_A_SIMD_registers_Msk (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/) /*!< MVFR0: A_SIMD registers bits Mask */ + +/* Media and FP Feature Register 1 Definitions */ +#define FPU_MVFR1_FP_fused_MAC_Pos 28U /*!< MVFR1: FP fused MAC bits Position */ +#define FPU_MVFR1_FP_fused_MAC_Msk (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos) /*!< MVFR1: FP fused MAC bits Mask */ + +#define FPU_MVFR1_FP_HPFP_Pos 24U /*!< MVFR1: FP HPFP bits Position */ +#define FPU_MVFR1_FP_HPFP_Msk (0xFUL << FPU_MVFR1_FP_HPFP_Pos) /*!< MVFR1: FP HPFP bits Mask */ + +#define FPU_MVFR1_D_NaN_mode_Pos 4U /*!< MVFR1: D_NaN mode bits Position */ +#define FPU_MVFR1_D_NaN_mode_Msk (0xFUL << FPU_MVFR1_D_NaN_mode_Pos) /*!< MVFR1: D_NaN mode bits Mask */ + +#define FPU_MVFR1_FtZ_mode_Pos 0U /*!< MVFR1: FtZ mode bits Position */ +#define FPU_MVFR1_FtZ_mode_Msk (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/) /*!< MVFR1: FtZ mode bits Mask */ + +/* Media and FP Feature Register 2 Definitions */ + +#define FPU_MVFR2_VFP_Misc_Pos 4U /*!< MVFR2: VFP Misc bits Position */ +#define FPU_MVFR2_VFP_Misc_Msk (0xFUL << FPU_MVFR2_VFP_Misc_Pos) /*!< MVFR2: VFP Misc bits Mask */ + +/*@} end of group CMSIS_FPU */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ +#define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ +#define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ +#define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ +#define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ +#define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ +#define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ +#define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE) /*!< Core Debug configuration struct */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ +#endif + +#define FPU_BASE (SCS_BASE + 0x0F30UL) /*!< Floating Point Unit */ +#define FPU ((FPU_Type *) FPU_BASE ) /*!< Floating Point Unit */ + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ +#define EXC_RETURN_HANDLER_FPU (0xFFFFFFE1UL) /* return to Handler mode, uses MSP after return, restore floating-point state */ +#define EXC_RETURN_THREAD_MSP_FPU (0xFFFFFFE9UL) /* return to Thread mode, uses MSP after return, restore floating-point state */ +#define EXC_RETURN_THREAD_PSP_FPU (0xFFFFFFEDUL) /* return to Thread mode, uses PSP after return, restore floating-point state */ + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IP[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector; + __DSB(); +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)); +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + +/* ########################## MPU functions #################################### */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + +#include "mpu_armv7.h" + +#endif + + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + uint32_t mvfr0; + + mvfr0 = SCB->MVFR0; + if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U) + { + return 2U; /* Double + Single precision FPU */ + } + else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U) + { + return 1U; /* Single precision FPU */ + } + else + { + return 0U; /* No FPU */ + } +} + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ########################## Cache functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_CacheFunctions Cache Functions + \brief Functions that configure Instruction and Data cache. + @{ + */ + +/* Cache Size ID Register Macros */ +#define CCSIDR_WAYS(x) (((x) & SCB_CCSIDR_ASSOCIATIVITY_Msk) >> SCB_CCSIDR_ASSOCIATIVITY_Pos) +#define CCSIDR_SETS(x) (((x) & SCB_CCSIDR_NUMSETS_Msk ) >> SCB_CCSIDR_NUMSETS_Pos ) + +#define __SCB_DCACHE_LINE_SIZE 32U /*!< Cortex-M7 cache line size is fixed to 32 bytes (8 words). See also register SCB_CCSIDR */ +#define __SCB_ICACHE_LINE_SIZE 32U /*!< Cortex-M7 cache line size is fixed to 32 bytes (8 words). See also register SCB_CCSIDR */ + +/** + \brief Enable I-Cache + \details Turns on I-Cache + */ +__STATIC_FORCEINLINE void SCB_EnableICache (void) +{ + #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U) + if (SCB->CCR & SCB_CCR_IC_Msk) return; /* return if ICache is already enabled */ + + __DSB(); + __ISB(); + SCB->ICIALLU = 0UL; /* invalidate I-Cache */ + __DSB(); + __ISB(); + SCB->CCR |= (uint32_t)SCB_CCR_IC_Msk; /* enable I-Cache */ + __DSB(); + __ISB(); + #endif +} + + +/** + \brief Disable I-Cache + \details Turns off I-Cache + */ +__STATIC_FORCEINLINE void SCB_DisableICache (void) +{ + #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U) + __DSB(); + __ISB(); + SCB->CCR &= ~(uint32_t)SCB_CCR_IC_Msk; /* disable I-Cache */ + SCB->ICIALLU = 0UL; /* invalidate I-Cache */ + __DSB(); + __ISB(); + #endif +} + + +/** + \brief Invalidate I-Cache + \details Invalidates I-Cache + */ +__STATIC_FORCEINLINE void SCB_InvalidateICache (void) +{ + #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U) + __DSB(); + __ISB(); + SCB->ICIALLU = 0UL; + __DSB(); + __ISB(); + #endif +} + + +/** + \brief I-Cache Invalidate by address + \details Invalidates I-Cache for the given address. + I-Cache is invalidated starting from a 32 byte aligned address in 32 byte granularity. + I-Cache memory blocks which are part of given address + given size are invalidated. + \param[in] addr address + \param[in] isize size of memory block (in number of bytes) +*/ +__STATIC_FORCEINLINE void SCB_InvalidateICache_by_Addr (void *addr, int32_t isize) +{ + #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U) + if ( isize > 0 ) { + int32_t op_size = isize + (((uint32_t)addr) & (__SCB_ICACHE_LINE_SIZE - 1U)); + uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_ICACHE_LINE_SIZE - 1U) */; + + __DSB(); + + do { + SCB->ICIMVAU = op_addr; /* register accepts only 32byte aligned values, only bits 31..5 are valid */ + op_addr += __SCB_ICACHE_LINE_SIZE; + op_size -= __SCB_ICACHE_LINE_SIZE; + } while ( op_size > 0 ); + + __DSB(); + __ISB(); + } + #endif +} + + +/** + \brief Enable D-Cache + \details Turns on D-Cache + */ +__STATIC_FORCEINLINE void SCB_EnableDCache (void) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + uint32_t ccsidr; + uint32_t sets; + uint32_t ways; + + if (SCB->CCR & SCB_CCR_DC_Msk) return; /* return if DCache is already enabled */ + + SCB->CSSELR = 0U; /* select Level 1 data cache */ + __DSB(); + + ccsidr = SCB->CCSIDR; + + /* invalidate D-Cache */ + sets = (uint32_t)(CCSIDR_SETS(ccsidr)); + do { + ways = (uint32_t)(CCSIDR_WAYS(ccsidr)); + do { + SCB->DCISW = (((sets << SCB_DCISW_SET_Pos) & SCB_DCISW_SET_Msk) | + ((ways << SCB_DCISW_WAY_Pos) & SCB_DCISW_WAY_Msk) ); + #if defined ( __CC_ARM ) + __schedule_barrier(); + #endif + } while (ways-- != 0U); + } while(sets-- != 0U); + __DSB(); + + SCB->CCR |= (uint32_t)SCB_CCR_DC_Msk; /* enable D-Cache */ + + __DSB(); + __ISB(); + #endif +} + + +/** + \brief Disable D-Cache + \details Turns off D-Cache + */ +__STATIC_FORCEINLINE void SCB_DisableDCache (void) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + register uint32_t ccsidr; + register uint32_t sets; + register uint32_t ways; + + SCB->CSSELR = 0U; /* select Level 1 data cache */ + __DSB(); + + SCB->CCR &= ~(uint32_t)SCB_CCR_DC_Msk; /* disable D-Cache */ + __DSB(); + + ccsidr = SCB->CCSIDR; + + /* clean & invalidate D-Cache */ + sets = (uint32_t)(CCSIDR_SETS(ccsidr)); + do { + ways = (uint32_t)(CCSIDR_WAYS(ccsidr)); + do { + SCB->DCCISW = (((sets << SCB_DCCISW_SET_Pos) & SCB_DCCISW_SET_Msk) | + ((ways << SCB_DCCISW_WAY_Pos) & SCB_DCCISW_WAY_Msk) ); + #if defined ( __CC_ARM ) + __schedule_barrier(); + #endif + } while (ways-- != 0U); + } while(sets-- != 0U); + + __DSB(); + __ISB(); + #endif +} + + +/** + \brief Invalidate D-Cache + \details Invalidates D-Cache + */ +__STATIC_FORCEINLINE void SCB_InvalidateDCache (void) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + uint32_t ccsidr; + uint32_t sets; + uint32_t ways; + + SCB->CSSELR = 0U; /* select Level 1 data cache */ + __DSB(); + + ccsidr = SCB->CCSIDR; + + /* invalidate D-Cache */ + sets = (uint32_t)(CCSIDR_SETS(ccsidr)); + do { + ways = (uint32_t)(CCSIDR_WAYS(ccsidr)); + do { + SCB->DCISW = (((sets << SCB_DCISW_SET_Pos) & SCB_DCISW_SET_Msk) | + ((ways << SCB_DCISW_WAY_Pos) & SCB_DCISW_WAY_Msk) ); + #if defined ( __CC_ARM ) + __schedule_barrier(); + #endif + } while (ways-- != 0U); + } while(sets-- != 0U); + + __DSB(); + __ISB(); + #endif +} + + +/** + \brief Clean D-Cache + \details Cleans D-Cache + */ +__STATIC_FORCEINLINE void SCB_CleanDCache (void) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + uint32_t ccsidr; + uint32_t sets; + uint32_t ways; + + SCB->CSSELR = 0U; /* select Level 1 data cache */ + __DSB(); + + ccsidr = SCB->CCSIDR; + + /* clean D-Cache */ + sets = (uint32_t)(CCSIDR_SETS(ccsidr)); + do { + ways = (uint32_t)(CCSIDR_WAYS(ccsidr)); + do { + SCB->DCCSW = (((sets << SCB_DCCSW_SET_Pos) & SCB_DCCSW_SET_Msk) | + ((ways << SCB_DCCSW_WAY_Pos) & SCB_DCCSW_WAY_Msk) ); + #if defined ( __CC_ARM ) + __schedule_barrier(); + #endif + } while (ways-- != 0U); + } while(sets-- != 0U); + + __DSB(); + __ISB(); + #endif +} + + +/** + \brief Clean & Invalidate D-Cache + \details Cleans and Invalidates D-Cache + */ +__STATIC_FORCEINLINE void SCB_CleanInvalidateDCache (void) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + uint32_t ccsidr; + uint32_t sets; + uint32_t ways; + + SCB->CSSELR = 0U; /* select Level 1 data cache */ + __DSB(); + + ccsidr = SCB->CCSIDR; + + /* clean & invalidate D-Cache */ + sets = (uint32_t)(CCSIDR_SETS(ccsidr)); + do { + ways = (uint32_t)(CCSIDR_WAYS(ccsidr)); + do { + SCB->DCCISW = (((sets << SCB_DCCISW_SET_Pos) & SCB_DCCISW_SET_Msk) | + ((ways << SCB_DCCISW_WAY_Pos) & SCB_DCCISW_WAY_Msk) ); + #if defined ( __CC_ARM ) + __schedule_barrier(); + #endif + } while (ways-- != 0U); + } while(sets-- != 0U); + + __DSB(); + __ISB(); + #endif +} + + +/** + \brief D-Cache Invalidate by address + \details Invalidates D-Cache for the given address. + D-Cache is invalidated starting from a 32 byte aligned address in 32 byte granularity. + D-Cache memory blocks which are part of given address + given size are invalidated. + \param[in] addr address + \param[in] dsize size of memory block (in number of bytes) +*/ +__STATIC_FORCEINLINE void SCB_InvalidateDCache_by_Addr (void *addr, int32_t dsize) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + if ( dsize > 0 ) { + int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U)); + uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */; + + __DSB(); + + do { + SCB->DCIMVAC = op_addr; /* register accepts only 32byte aligned values, only bits 31..5 are valid */ + op_addr += __SCB_DCACHE_LINE_SIZE; + op_size -= __SCB_DCACHE_LINE_SIZE; + } while ( op_size > 0 ); + + __DSB(); + __ISB(); + } + #endif +} + + +/** + \brief D-Cache Clean by address + \details Cleans D-Cache for the given address + D-Cache is cleaned starting from a 32 byte aligned address in 32 byte granularity. + D-Cache memory blocks which are part of given address + given size are cleaned. + \param[in] addr address + \param[in] dsize size of memory block (in number of bytes) +*/ +__STATIC_FORCEINLINE void SCB_CleanDCache_by_Addr (uint32_t *addr, int32_t dsize) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + if ( dsize > 0 ) { + int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U)); + uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */; + + __DSB(); + + do { + SCB->DCCMVAC = op_addr; /* register accepts only 32byte aligned values, only bits 31..5 are valid */ + op_addr += __SCB_DCACHE_LINE_SIZE; + op_size -= __SCB_DCACHE_LINE_SIZE; + } while ( op_size > 0 ); + + __DSB(); + __ISB(); + } + #endif +} + + +/** + \brief D-Cache Clean and Invalidate by address + \details Cleans and invalidates D_Cache for the given address + D-Cache is cleaned and invalidated starting from a 32 byte aligned address in 32 byte granularity. + D-Cache memory blocks which are part of given address + given size are cleaned and invalidated. + \param[in] addr address (aligned to 32-byte boundary) + \param[in] dsize size of memory block (in number of bytes) +*/ +__STATIC_FORCEINLINE void SCB_CleanInvalidateDCache_by_Addr (uint32_t *addr, int32_t dsize) +{ + #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) + if ( dsize > 0 ) { + int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U)); + uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */; + + __DSB(); + + do { + SCB->DCCIMVAC = op_addr; /* register accepts only 32byte aligned values, only bits 31..5 are valid */ + op_addr += __SCB_DCACHE_LINE_SIZE; + op_size -= __SCB_DCACHE_LINE_SIZE; + } while ( op_size > 0 ); + + __DSB(); + __ISB(); + } + #endif +} + +/*@} end of CMSIS_Core_CacheFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_CM7_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_dsp.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_dsp.h new file mode 100644 index 0000000000..6c21a47d80 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_dsp.h @@ -0,0 +1,74 @@ +/**************************************************************************//** + * @file cmsis_xcc.h + * @brief CMSIS DSP Core Peripheral Access Layer Header File + * @version V1.0 + * @date 20. January 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 ARM Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CORE_DSP_H_GENERIC +#define __CORE_DSP_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +#define __STATIC_INLINE static inline + +#define __BKPT(value) do {} while(0) +#define __NOP() do {} while(0) + +#define NVIC_SetPriorityGrouping(value) do {} while(0) +#define NVIC_GetPriorityGrouping() do {} while(0) +#define NVIC_EnableIRQ(value) do {} while(0) +#define NVIC_GetEnableIRQ(value) do {} while(0) +#define NVIC_DisableIRQ(value) do {} while(0) +#define NVIC_GetPendingIRQ(value) do {} while(0) +#define NVIC_SetPendingIRQ(value) do {} while(0) +#define NVIC_ClearPendingIRQ(value) do {} while(0) +#define NVIC_GetActive(value) do {} while(0) + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_DSP_H_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc000.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc000.h new file mode 100644 index 0000000000..cf92577b63 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc000.h @@ -0,0 +1,1025 @@ +/**************************************************************************//** + * @file core_sc000.h + * @brief CMSIS SC000 Core Peripheral Access Layer Header File + * @version V5.0.6 + * @date 12. November 2018 + ******************************************************************************/ +/* + * Copyright (c) 2009-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_SC000_H_GENERIC +#define __CORE_SC000_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup SC000 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS SC000 definitions */ +#define __SC000_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __SC000_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __SC000_CMSIS_VERSION ((__SC000_CMSIS_VERSION_MAIN << 16U) | \ + __SC000_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_SC (000U) /*!< Cortex secure core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_SC000_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_SC000_H_DEPENDANT +#define __CORE_SC000_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __SC000_REV + #define __SC000_REV 0x0000U + #warning "__SC000_REV not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group SC000 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core MPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:28; /*!< bit: 0..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t _reserved1:3; /*!< bit: 25..27 Reserved */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t _reserved0:1; /*!< bit: 0 Reserved */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[1U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[31U]; + __IOM uint32_t ICER[1U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[31U]; + __IOM uint32_t ISPR[1U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[31U]; + __IOM uint32_t ICPR[1U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[31U]; + uint32_t RESERVED4[64U]; + __IOM uint32_t IP[8U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED0[1U]; + __IOM uint32_t SHP[2U]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + uint32_t RESERVED1[154U]; + __IOM uint32_t SFCR; /*!< Offset: 0x290 (R/W) Security Features Control Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ +} SCnSCB_Type; + +/* Auxiliary Control Register Definitions */ +#define SCnSCB_ACTLR_DISMCYCINT_Pos 0U /*!< ACTLR: DISMCYCINT Position */ +#define SCnSCB_ACTLR_DISMCYCINT_Msk (1UL /*<< SCnSCB_ACTLR_DISMCYCINT_Pos*/) /*!< ACTLR: DISMCYCINT Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region RNRber Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RASR; /*!< Offset: 0x010 (R/W) MPU Region Attribute and Size Register */ +} MPU_Type; + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_ADDR_Pos 8U /*!< MPU RBAR: ADDR Position */ +#define MPU_RBAR_ADDR_Msk (0xFFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */ + +#define MPU_RBAR_VALID_Pos 4U /*!< MPU RBAR: VALID Position */ +#define MPU_RBAR_VALID_Msk (1UL << MPU_RBAR_VALID_Pos) /*!< MPU RBAR: VALID Mask */ + +#define MPU_RBAR_REGION_Pos 0U /*!< MPU RBAR: REGION Position */ +#define MPU_RBAR_REGION_Msk (0xFUL /*<< MPU_RBAR_REGION_Pos*/) /*!< MPU RBAR: REGION Mask */ + +/* MPU Region Attribute and Size Register Definitions */ +#define MPU_RASR_ATTRS_Pos 16U /*!< MPU RASR: MPU Region Attribute field Position */ +#define MPU_RASR_ATTRS_Msk (0xFFFFUL << MPU_RASR_ATTRS_Pos) /*!< MPU RASR: MPU Region Attribute field Mask */ + +#define MPU_RASR_XN_Pos 28U /*!< MPU RASR: ATTRS.XN Position */ +#define MPU_RASR_XN_Msk (1UL << MPU_RASR_XN_Pos) /*!< MPU RASR: ATTRS.XN Mask */ + +#define MPU_RASR_AP_Pos 24U /*!< MPU RASR: ATTRS.AP Position */ +#define MPU_RASR_AP_Msk (0x7UL << MPU_RASR_AP_Pos) /*!< MPU RASR: ATTRS.AP Mask */ + +#define MPU_RASR_TEX_Pos 19U /*!< MPU RASR: ATTRS.TEX Position */ +#define MPU_RASR_TEX_Msk (0x7UL << MPU_RASR_TEX_Pos) /*!< MPU RASR: ATTRS.TEX Mask */ + +#define MPU_RASR_S_Pos 18U /*!< MPU RASR: ATTRS.S Position */ +#define MPU_RASR_S_Msk (1UL << MPU_RASR_S_Pos) /*!< MPU RASR: ATTRS.S Mask */ + +#define MPU_RASR_C_Pos 17U /*!< MPU RASR: ATTRS.C Position */ +#define MPU_RASR_C_Msk (1UL << MPU_RASR_C_Pos) /*!< MPU RASR: ATTRS.C Mask */ + +#define MPU_RASR_B_Pos 16U /*!< MPU RASR: ATTRS.B Position */ +#define MPU_RASR_B_Msk (1UL << MPU_RASR_B_Pos) /*!< MPU RASR: ATTRS.B Mask */ + +#define MPU_RASR_SRD_Pos 8U /*!< MPU RASR: Sub-Region Disable Position */ +#define MPU_RASR_SRD_Msk (0xFFUL << MPU_RASR_SRD_Pos) /*!< MPU RASR: Sub-Region Disable Mask */ + +#define MPU_RASR_SIZE_Pos 1U /*!< MPU RASR: Region Size Field Position */ +#define MPU_RASR_SIZE_Msk (0x1FUL << MPU_RASR_SIZE_Pos) /*!< MPU RASR: Region Size Field Mask */ + +#define MPU_RASR_ENABLE_Pos 0U /*!< MPU RASR: Region enable bit Position */ +#define MPU_RASR_ENABLE_Msk (1UL /*<< MPU_RASR_ENABLE_Pos*/) /*!< MPU RASR: Region enable bit Disable Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief SC000 Core Debug Registers (DCB registers, SHCSR, and DFSR) are only accessible over DAP and not via processor. + Therefore they are not covered by the SC000 header file. + @{ + */ +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ +#endif + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else +/*#define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping not available for SC000 */ +/*#define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping not available for SC000 */ + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ +/*#define NVIC_GetActive __NVIC_GetActive not available for SC000 */ + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ + + +/* Interrupt Priorities are WORD accessible only under Armv6-M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( ((((uint32_t)(int32_t)(IRQn)) ) & 0x03UL) * 8UL) +#define _SHP_IDX(IRQn) ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >> 2UL) ) +#define _IP_IDX(IRQn) ( (((uint32_t)(int32_t)(IRQn)) >> 2UL) ) + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[_IP_IDX(IRQn)] = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } + else + { + SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) | + (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn))); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector; + /* ARM Application Note 321 states that the M0 and M0+ do not require the architectural barrier - assume SC000 is the same */ +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t *vectors = (uint32_t *)SCB->VTOR; + return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET]; +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_SC000_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc300.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc300.h new file mode 100644 index 0000000000..40f3af81be --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/core_sc300.h @@ -0,0 +1,1912 @@ +/**************************************************************************//** + * @file core_sc300.h + * @brief CMSIS SC300 Core Peripheral Access Layer Header File + * @version V5.0.8 + * @date 31. May 2019 + ******************************************************************************/ +/* + * Copyright (c) 2009-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef __CORE_SC300_H_GENERIC +#define __CORE_SC300_H_GENERIC + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
+ Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
+ Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
+ Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** + \ingroup SC3000 + @{ + */ + +#include "cmsis_version.h" + +/* CMSIS SC300 definitions */ +#define __SC300_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */ +#define __SC300_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */ +#define __SC300_CMSIS_VERSION ((__SC300_CMSIS_VERSION_MAIN << 16U) | \ + __SC300_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */ + +#define __CORTEX_SC (300U) /*!< Cortex secure core */ + +/** __FPU_USED indicates whether an FPU is used or not. + This core does not support an FPU at all +*/ +#define __FPU_USED 0U + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #if defined __ARM_FP + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TI_ARM__ ) + #if defined __TI_VFP_SUPPORT__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __CSMC__ ) + #if ( __CSMC__ & 0x400U) + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#endif + +#include "cmsis_compiler.h" /* CMSIS compiler specific defines */ + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_SC300_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_SC300_H_DEPENDANT +#define __CORE_SC300_H_DEPENDANT + +#ifdef __cplusplus + extern "C" { +#endif + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __SC300_REV + #define __SC300_REV 0x0000U + #warning "__SC300_REV not defined in device header file; using default!" + #endif + + #ifndef __MPU_PRESENT + #define __MPU_PRESENT 0U + #warning "__MPU_PRESENT not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 3U + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0U + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/* following defines should be used for structure members */ +#define __IM volatile const /*! Defines 'read only' structure member permissions */ +#define __OM volatile /*! Defines 'write only' structure member permissions */ +#define __IOM volatile /*! Defines 'read / write' structure member permissions */ + +/*@} end of group SC300 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + - Core Debug Register + - Core MPU Register + ******************************************************************************/ +/** + \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** + \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { + uint32_t _reserved0:27; /*!< bit: 0..26 Reserved */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + +/* APSR Register Definitions */ +#define APSR_N_Pos 31U /*!< APSR: N Position */ +#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */ + +#define APSR_Z_Pos 30U /*!< APSR: Z Position */ +#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */ + +#define APSR_C_Pos 29U /*!< APSR: C Position */ +#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */ + +#define APSR_V_Pos 28U /*!< APSR: V Position */ +#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */ + +#define APSR_Q_Pos 27U /*!< APSR: Q Position */ +#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */ + + +/** + \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + +/* IPSR Register Definitions */ +#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */ +#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */ + + +/** + \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:1; /*!< bit: 9 Reserved */ + uint32_t ICI_IT_1:6; /*!< bit: 10..15 ICI/IT part 1 */ + uint32_t _reserved1:8; /*!< bit: 16..23 Reserved */ + uint32_t T:1; /*!< bit: 24 Thumb bit */ + uint32_t ICI_IT_2:2; /*!< bit: 25..26 ICI/IT part 2 */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + +/* xPSR Register Definitions */ +#define xPSR_N_Pos 31U /*!< xPSR: N Position */ +#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */ + +#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */ +#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */ + +#define xPSR_C_Pos 29U /*!< xPSR: C Position */ +#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */ + +#define xPSR_V_Pos 28U /*!< xPSR: V Position */ +#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */ + +#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */ +#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */ + +#define xPSR_ICI_IT_2_Pos 25U /*!< xPSR: ICI/IT part 2 Position */ +#define xPSR_ICI_IT_2_Msk (3UL << xPSR_ICI_IT_2_Pos) /*!< xPSR: ICI/IT part 2 Mask */ + +#define xPSR_T_Pos 24U /*!< xPSR: T Position */ +#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */ + +#define xPSR_ICI_IT_1_Pos 10U /*!< xPSR: ICI/IT part 1 Position */ +#define xPSR_ICI_IT_1_Msk (0x3FUL << xPSR_ICI_IT_1_Pos) /*!< xPSR: ICI/IT part 1 Mask */ + +#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */ +#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */ + + +/** + \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t _reserved1:30; /*!< bit: 2..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/* CONTROL Register Definitions */ +#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */ +#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */ + +#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */ +#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */ + +/*@} end of group CMSIS_CORE */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** + \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IOM uint32_t ISER[8U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[24U]; + __IOM uint32_t ICER[8U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RESERVED1[24U]; + __IOM uint32_t ISPR[8U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[24U]; + __IOM uint32_t ICPR[8U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[24U]; + __IOM uint32_t IABR[8U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */ + uint32_t RESERVED4[56U]; + __IOM uint8_t IP[240U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */ + uint32_t RESERVED5[644U]; + __OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */ +} NVIC_Type; + +/* Software Triggered Interrupt Register Definitions */ +#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */ +#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */ + +/*@} end of group CMSIS_NVIC */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** + \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + __IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */ + __IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + __IOM uint8_t SHP[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */ + __IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ + __IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */ + __IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */ + __IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */ + __IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */ + __IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */ + __IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */ + __IM uint32_t PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */ + __IM uint32_t DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */ + __IM uint32_t ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */ + __IM uint32_t MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */ + __IM uint32_t ISAR[5U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */ + uint32_t RESERVED0[5U]; + __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ + uint32_t RESERVED1[129U]; + __IOM uint32_t SFCR; /*!< Offset: 0x290 (R/W) Security Features Control Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */ +#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Vector Table Offset Register Definitions */ +#define SCB_VTOR_TBLBASE_Pos 29U /*!< SCB VTOR: TBLBASE Position */ +#define SCB_VTOR_TBLBASE_Msk (1UL << SCB_VTOR_TBLBASE_Pos) /*!< SCB VTOR: TBLBASE Mask */ + +#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */ +#define SCB_VTOR_TBLOFF_Msk (0x3FFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */ +#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +#define SCB_AIRCR_VECTRESET_Pos 0U /*!< SCB AIRCR: VECTRESET Position */ +#define SCB_AIRCR_VECTRESET_Msk (1UL /*<< SCB_AIRCR_VECTRESET_Pos*/) /*!< SCB AIRCR: VECTRESET Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */ +#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */ + +#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */ +#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */ +#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */ + +#define SCB_CCR_NONBASETHRDENA_Pos 0U /*!< SCB CCR: NONBASETHRDENA Position */ +#define SCB_CCR_NONBASETHRDENA_Msk (1UL /*<< SCB_CCR_NONBASETHRDENA_Pos*/) /*!< SCB CCR: NONBASETHRDENA Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */ +#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */ + +#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */ +#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */ + +#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */ +#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */ + +#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */ +#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */ + +#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */ +#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */ + +#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */ +#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */ + +#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */ +#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */ + +#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */ +#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */ + +#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */ +#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */ + +#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */ +#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */ + +#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */ +#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */ + +#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */ +#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */ + +#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */ +#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */ + +/* SCB Configurable Fault Status Register Definitions */ +#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */ +#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */ + +#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */ +#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */ + +#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */ +#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */ + +/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */ +#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */ + +#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */ +#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */ + +#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */ +#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */ + +#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */ +#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */ + +#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */ +#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */ + +/* BusFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */ +#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */ + +#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */ +#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */ + +#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */ +#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */ + +#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */ +#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */ + +#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */ +#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */ + +#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */ +#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */ + +/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */ +#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */ +#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */ + +#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */ +#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */ + +#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */ +#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */ + +#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */ +#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */ + +#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */ +#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */ + +#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */ +#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */ + +/* SCB Hard Fault Status Register Definitions */ +#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */ +#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */ + +#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */ +#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */ + +#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */ +#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */ + +/* SCB Debug Fault Status Register Definitions */ +#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */ +#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */ + +#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */ +#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */ + +#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */ +#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */ + +#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */ +#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */ + +#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */ +#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB) + \brief Type definitions for the System Control and ID Register not in the SCB + @{ + */ + +/** + \brief Structure type to access the System Control and ID Register not in the SCB. + */ +typedef struct +{ + uint32_t RESERVED0[1U]; + __IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */ + __IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */ +} SCnSCB_Type; + +/* Interrupt Controller Type Register Definitions */ +#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */ +#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */ + +/* Auxiliary Control Register Definitions */ +#define SCnSCB_ACTLR_DISFOLD_Pos 2U /*!< ACTLR: DISFOLD Position */ +#define SCnSCB_ACTLR_DISFOLD_Msk (1UL << SCnSCB_ACTLR_DISFOLD_Pos) /*!< ACTLR: DISFOLD Mask */ + +#define SCnSCB_ACTLR_DISDEFWBUF_Pos 1U /*!< ACTLR: DISDEFWBUF Position */ +#define SCnSCB_ACTLR_DISDEFWBUF_Msk (1UL << SCnSCB_ACTLR_DISDEFWBUF_Pos) /*!< ACTLR: DISDEFWBUF Mask */ + +#define SCnSCB_ACTLR_DISMCYCINT_Pos 0U /*!< ACTLR: DISMCYCINT Position */ +#define SCnSCB_ACTLR_DISMCYCINT_Msk (1UL /*<< SCnSCB_ACTLR_DISMCYCINT_Pos*/) /*!< ACTLR: DISMCYCINT Mask */ + +/*@} end of group CMSIS_SCnotSCB */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** + \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM) + \brief Type definitions for the Instrumentation Trace Macrocell (ITM) + @{ + */ + +/** + \brief Structure type to access the Instrumentation Trace Macrocell Register (ITM). + */ +typedef struct +{ + __OM union + { + __OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */ + __OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */ + __OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */ + } PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */ + uint32_t RESERVED0[864U]; + __IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */ + uint32_t RESERVED1[15U]; + __IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */ + uint32_t RESERVED2[15U]; + __IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */ + uint32_t RESERVED3[32U]; + uint32_t RESERVED4[43U]; + __OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */ + __IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */ + uint32_t RESERVED5[6U]; + __IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */ + __IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */ + __IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */ + __IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */ + __IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */ + __IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */ + __IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */ + __IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */ + __IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */ + __IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */ + __IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */ + __IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */ +} ITM_Type; + +/* ITM Trace Privilege Register Definitions */ +#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */ +#define ITM_TPR_PRIVMASK_Msk (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */ + +/* ITM Trace Control Register Definitions */ +#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */ +#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */ + +#define ITM_TCR_TraceBusID_Pos 16U /*!< ITM TCR: ATBID Position */ +#define ITM_TCR_TraceBusID_Msk (0x7FUL << ITM_TCR_TraceBusID_Pos) /*!< ITM TCR: ATBID Mask */ + +#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */ +#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */ + +#define ITM_TCR_TSPrescale_Pos 8U /*!< ITM TCR: TSPrescale Position */ +#define ITM_TCR_TSPrescale_Msk (3UL << ITM_TCR_TSPrescale_Pos) /*!< ITM TCR: TSPrescale Mask */ + +#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */ +#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */ + +#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */ +#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */ + +#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */ +#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */ + +#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */ +#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */ + +#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */ +#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */ + +/* ITM Lock Status Register Definitions */ +#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */ +#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */ + +#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */ +#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */ + +#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */ +#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */ + +/*@}*/ /* end of group CMSIS_ITM */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_DWT Data Watchpoint and Trace (DWT) + \brief Type definitions for the Data Watchpoint and Trace (DWT) + @{ + */ + +/** + \brief Structure type to access the Data Watchpoint and Trace Register (DWT). + */ +typedef struct +{ + __IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */ + __IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */ + __IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */ + __IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */ + __IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */ + __IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */ + __IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */ + __IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */ + __IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */ + __IOM uint32_t MASK0; /*!< Offset: 0x024 (R/W) Mask Register 0 */ + __IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */ + uint32_t RESERVED0[1U]; + __IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */ + __IOM uint32_t MASK1; /*!< Offset: 0x034 (R/W) Mask Register 1 */ + __IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */ + uint32_t RESERVED1[1U]; + __IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */ + __IOM uint32_t MASK2; /*!< Offset: 0x044 (R/W) Mask Register 2 */ + __IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */ + uint32_t RESERVED2[1U]; + __IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */ + __IOM uint32_t MASK3; /*!< Offset: 0x054 (R/W) Mask Register 3 */ + __IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */ +} DWT_Type; + +/* DWT Control Register Definitions */ +#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */ +#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */ + +#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */ +#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */ + +#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */ +#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */ + +#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */ +#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */ + +#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */ +#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */ + +#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */ +#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */ + +#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */ +#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */ + +#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */ +#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */ + +#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */ +#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */ + +#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */ +#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */ + +#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */ +#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */ + +#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */ +#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */ + +#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */ +#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */ + +#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */ +#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */ + +#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */ +#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */ + +#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */ +#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */ + +#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */ +#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */ + +#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */ +#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */ + +/* DWT CPI Count Register Definitions */ +#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */ +#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */ + +/* DWT Exception Overhead Count Register Definitions */ +#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */ +#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */ + +/* DWT Sleep Count Register Definitions */ +#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */ +#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */ + +/* DWT LSU Count Register Definitions */ +#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */ +#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */ + +/* DWT Folded-instruction Count Register Definitions */ +#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */ +#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */ + +/* DWT Comparator Mask Register Definitions */ +#define DWT_MASK_MASK_Pos 0U /*!< DWT MASK: MASK Position */ +#define DWT_MASK_MASK_Msk (0x1FUL /*<< DWT_MASK_MASK_Pos*/) /*!< DWT MASK: MASK Mask */ + +/* DWT Comparator Function Register Definitions */ +#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */ +#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */ + +#define DWT_FUNCTION_DATAVADDR1_Pos 16U /*!< DWT FUNCTION: DATAVADDR1 Position */ +#define DWT_FUNCTION_DATAVADDR1_Msk (0xFUL << DWT_FUNCTION_DATAVADDR1_Pos) /*!< DWT FUNCTION: DATAVADDR1 Mask */ + +#define DWT_FUNCTION_DATAVADDR0_Pos 12U /*!< DWT FUNCTION: DATAVADDR0 Position */ +#define DWT_FUNCTION_DATAVADDR0_Msk (0xFUL << DWT_FUNCTION_DATAVADDR0_Pos) /*!< DWT FUNCTION: DATAVADDR0 Mask */ + +#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */ +#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */ + +#define DWT_FUNCTION_LNK1ENA_Pos 9U /*!< DWT FUNCTION: LNK1ENA Position */ +#define DWT_FUNCTION_LNK1ENA_Msk (0x1UL << DWT_FUNCTION_LNK1ENA_Pos) /*!< DWT FUNCTION: LNK1ENA Mask */ + +#define DWT_FUNCTION_DATAVMATCH_Pos 8U /*!< DWT FUNCTION: DATAVMATCH Position */ +#define DWT_FUNCTION_DATAVMATCH_Msk (0x1UL << DWT_FUNCTION_DATAVMATCH_Pos) /*!< DWT FUNCTION: DATAVMATCH Mask */ + +#define DWT_FUNCTION_CYCMATCH_Pos 7U /*!< DWT FUNCTION: CYCMATCH Position */ +#define DWT_FUNCTION_CYCMATCH_Msk (0x1UL << DWT_FUNCTION_CYCMATCH_Pos) /*!< DWT FUNCTION: CYCMATCH Mask */ + +#define DWT_FUNCTION_EMITRANGE_Pos 5U /*!< DWT FUNCTION: EMITRANGE Position */ +#define DWT_FUNCTION_EMITRANGE_Msk (0x1UL << DWT_FUNCTION_EMITRANGE_Pos) /*!< DWT FUNCTION: EMITRANGE Mask */ + +#define DWT_FUNCTION_FUNCTION_Pos 0U /*!< DWT FUNCTION: FUNCTION Position */ +#define DWT_FUNCTION_FUNCTION_Msk (0xFUL /*<< DWT_FUNCTION_FUNCTION_Pos*/) /*!< DWT FUNCTION: FUNCTION Mask */ + +/*@}*/ /* end of group CMSIS_DWT */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_TPI Trace Port Interface (TPI) + \brief Type definitions for the Trace Port Interface (TPI) + @{ + */ + +/** + \brief Structure type to access the Trace Port Interface Register (TPI). + */ +typedef struct +{ + __IM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */ + __IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */ + uint32_t RESERVED0[2U]; + __IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */ + uint32_t RESERVED1[55U]; + __IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */ + uint32_t RESERVED2[131U]; + __IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */ + __IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */ + __IM uint32_t FSCR; /*!< Offset: 0x308 (R/ ) Formatter Synchronization Counter Register */ + uint32_t RESERVED3[759U]; + __IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER Register */ + __IM uint32_t FIFO0; /*!< Offset: 0xEEC (R/ ) Integration ETM Data */ + __IM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/ ) ITATBCTR2 */ + uint32_t RESERVED4[1U]; + __IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) ITATBCTR0 */ + __IM uint32_t FIFO1; /*!< Offset: 0xEFC (R/ ) Integration ITM Data */ + __IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */ + uint32_t RESERVED5[39U]; + __IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */ + __IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */ + uint32_t RESERVED7[8U]; + __IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) TPIU_DEVID */ + __IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) TPIU_DEVTYPE */ +} TPI_Type; + +/* TPI Asynchronous Clock Prescaler Register Definitions */ +#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */ +#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */ + +/* TPI Selected Pin Protocol Register Definitions */ +#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */ +#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */ + +/* TPI Formatter and Flush Status Register Definitions */ +#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */ +#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */ + +#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */ +#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */ + +#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */ +#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */ + +#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */ +#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */ + +/* TPI Formatter and Flush Control Register Definitions */ +#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */ +#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */ + +#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */ +#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */ + +/* TPI TRIGGER Register Definitions */ +#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */ +#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */ + +/* TPI Integration ETM Data Register Definitions (FIFO0) */ +#define TPI_FIFO0_ITM_ATVALID_Pos 29U /*!< TPI FIFO0: ITM_ATVALID Position */ +#define TPI_FIFO0_ITM_ATVALID_Msk (0x1UL << TPI_FIFO0_ITM_ATVALID_Pos) /*!< TPI FIFO0: ITM_ATVALID Mask */ + +#define TPI_FIFO0_ITM_bytecount_Pos 27U /*!< TPI FIFO0: ITM_bytecount Position */ +#define TPI_FIFO0_ITM_bytecount_Msk (0x3UL << TPI_FIFO0_ITM_bytecount_Pos) /*!< TPI FIFO0: ITM_bytecount Mask */ + +#define TPI_FIFO0_ETM_ATVALID_Pos 26U /*!< TPI FIFO0: ETM_ATVALID Position */ +#define TPI_FIFO0_ETM_ATVALID_Msk (0x1UL << TPI_FIFO0_ETM_ATVALID_Pos) /*!< TPI FIFO0: ETM_ATVALID Mask */ + +#define TPI_FIFO0_ETM_bytecount_Pos 24U /*!< TPI FIFO0: ETM_bytecount Position */ +#define TPI_FIFO0_ETM_bytecount_Msk (0x3UL << TPI_FIFO0_ETM_bytecount_Pos) /*!< TPI FIFO0: ETM_bytecount Mask */ + +#define TPI_FIFO0_ETM2_Pos 16U /*!< TPI FIFO0: ETM2 Position */ +#define TPI_FIFO0_ETM2_Msk (0xFFUL << TPI_FIFO0_ETM2_Pos) /*!< TPI FIFO0: ETM2 Mask */ + +#define TPI_FIFO0_ETM1_Pos 8U /*!< TPI FIFO0: ETM1 Position */ +#define TPI_FIFO0_ETM1_Msk (0xFFUL << TPI_FIFO0_ETM1_Pos) /*!< TPI FIFO0: ETM1 Mask */ + +#define TPI_FIFO0_ETM0_Pos 0U /*!< TPI FIFO0: ETM0 Position */ +#define TPI_FIFO0_ETM0_Msk (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/) /*!< TPI FIFO0: ETM0 Mask */ + +/* TPI ITATBCTR2 Register Definitions */ +#define TPI_ITATBCTR2_ATREADY2_Pos 0U /*!< TPI ITATBCTR2: ATREADY2 Position */ +#define TPI_ITATBCTR2_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/) /*!< TPI ITATBCTR2: ATREADY2 Mask */ + +#define TPI_ITATBCTR2_ATREADY1_Pos 0U /*!< TPI ITATBCTR2: ATREADY1 Position */ +#define TPI_ITATBCTR2_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/) /*!< TPI ITATBCTR2: ATREADY1 Mask */ + +/* TPI Integration ITM Data Register Definitions (FIFO1) */ +#define TPI_FIFO1_ITM_ATVALID_Pos 29U /*!< TPI FIFO1: ITM_ATVALID Position */ +#define TPI_FIFO1_ITM_ATVALID_Msk (0x1UL << TPI_FIFO1_ITM_ATVALID_Pos) /*!< TPI FIFO1: ITM_ATVALID Mask */ + +#define TPI_FIFO1_ITM_bytecount_Pos 27U /*!< TPI FIFO1: ITM_bytecount Position */ +#define TPI_FIFO1_ITM_bytecount_Msk (0x3UL << TPI_FIFO1_ITM_bytecount_Pos) /*!< TPI FIFO1: ITM_bytecount Mask */ + +#define TPI_FIFO1_ETM_ATVALID_Pos 26U /*!< TPI FIFO1: ETM_ATVALID Position */ +#define TPI_FIFO1_ETM_ATVALID_Msk (0x1UL << TPI_FIFO1_ETM_ATVALID_Pos) /*!< TPI FIFO1: ETM_ATVALID Mask */ + +#define TPI_FIFO1_ETM_bytecount_Pos 24U /*!< TPI FIFO1: ETM_bytecount Position */ +#define TPI_FIFO1_ETM_bytecount_Msk (0x3UL << TPI_FIFO1_ETM_bytecount_Pos) /*!< TPI FIFO1: ETM_bytecount Mask */ + +#define TPI_FIFO1_ITM2_Pos 16U /*!< TPI FIFO1: ITM2 Position */ +#define TPI_FIFO1_ITM2_Msk (0xFFUL << TPI_FIFO1_ITM2_Pos) /*!< TPI FIFO1: ITM2 Mask */ + +#define TPI_FIFO1_ITM1_Pos 8U /*!< TPI FIFO1: ITM1 Position */ +#define TPI_FIFO1_ITM1_Msk (0xFFUL << TPI_FIFO1_ITM1_Pos) /*!< TPI FIFO1: ITM1 Mask */ + +#define TPI_FIFO1_ITM0_Pos 0U /*!< TPI FIFO1: ITM0 Position */ +#define TPI_FIFO1_ITM0_Msk (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/) /*!< TPI FIFO1: ITM0 Mask */ + +/* TPI ITATBCTR0 Register Definitions */ +#define TPI_ITATBCTR0_ATREADY2_Pos 0U /*!< TPI ITATBCTR0: ATREADY2 Position */ +#define TPI_ITATBCTR0_ATREADY2_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/) /*!< TPI ITATBCTR0: ATREADY2 Mask */ + +#define TPI_ITATBCTR0_ATREADY1_Pos 0U /*!< TPI ITATBCTR0: ATREADY1 Position */ +#define TPI_ITATBCTR0_ATREADY1_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/) /*!< TPI ITATBCTR0: ATREADY1 Mask */ + +/* TPI Integration Mode Control Register Definitions */ +#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */ +#define TPI_ITCTRL_Mode_Msk (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */ + +/* TPI DEVID Register Definitions */ +#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */ +#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */ + +#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */ +#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */ + +#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */ +#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */ + +#define TPI_DEVID_MinBufSz_Pos 6U /*!< TPI DEVID: MinBufSz Position */ +#define TPI_DEVID_MinBufSz_Msk (0x7UL << TPI_DEVID_MinBufSz_Pos) /*!< TPI DEVID: MinBufSz Mask */ + +#define TPI_DEVID_AsynClkIn_Pos 5U /*!< TPI DEVID: AsynClkIn Position */ +#define TPI_DEVID_AsynClkIn_Msk (0x1UL << TPI_DEVID_AsynClkIn_Pos) /*!< TPI DEVID: AsynClkIn Mask */ + +#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */ +#define TPI_DEVID_NrTraceInput_Msk (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */ + +/* TPI DEVTYPE Register Definitions */ +#define TPI_DEVTYPE_SubType_Pos 4U /*!< TPI DEVTYPE: SubType Position */ +#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */ + +#define TPI_DEVTYPE_MajorType_Pos 0U /*!< TPI DEVTYPE: MajorType Position */ +#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */ + +/*@}*/ /* end of group CMSIS_TPI */ + + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_MPU Memory Protection Unit (MPU) + \brief Type definitions for the Memory Protection Unit (MPU) + @{ + */ + +/** + \brief Structure type to access the Memory Protection Unit (MPU). + */ +typedef struct +{ + __IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */ + __IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */ + __IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region RNRber Register */ + __IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */ + __IOM uint32_t RASR; /*!< Offset: 0x010 (R/W) MPU Region Attribute and Size Register */ + __IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Alias 1 Region Base Address Register */ + __IOM uint32_t RASR_A1; /*!< Offset: 0x018 (R/W) MPU Alias 1 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Alias 2 Region Base Address Register */ + __IOM uint32_t RASR_A2; /*!< Offset: 0x020 (R/W) MPU Alias 2 Region Attribute and Size Register */ + __IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Alias 3 Region Base Address Register */ + __IOM uint32_t RASR_A3; /*!< Offset: 0x028 (R/W) MPU Alias 3 Region Attribute and Size Register */ +} MPU_Type; + +/* MPU Type Register Definitions */ +#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */ +#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */ + +#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */ +#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */ + +#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */ +#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */ + +/* MPU Control Register Definitions */ +#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */ +#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */ + +#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */ +#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */ + +#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */ +#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */ + +/* MPU Region Number Register Definitions */ +#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */ +#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */ + +/* MPU Region Base Address Register Definitions */ +#define MPU_RBAR_ADDR_Pos 5U /*!< MPU RBAR: ADDR Position */ +#define MPU_RBAR_ADDR_Msk (0x7FFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */ + +#define MPU_RBAR_VALID_Pos 4U /*!< MPU RBAR: VALID Position */ +#define MPU_RBAR_VALID_Msk (1UL << MPU_RBAR_VALID_Pos) /*!< MPU RBAR: VALID Mask */ + +#define MPU_RBAR_REGION_Pos 0U /*!< MPU RBAR: REGION Position */ +#define MPU_RBAR_REGION_Msk (0xFUL /*<< MPU_RBAR_REGION_Pos*/) /*!< MPU RBAR: REGION Mask */ + +/* MPU Region Attribute and Size Register Definitions */ +#define MPU_RASR_ATTRS_Pos 16U /*!< MPU RASR: MPU Region Attribute field Position */ +#define MPU_RASR_ATTRS_Msk (0xFFFFUL << MPU_RASR_ATTRS_Pos) /*!< MPU RASR: MPU Region Attribute field Mask */ + +#define MPU_RASR_XN_Pos 28U /*!< MPU RASR: ATTRS.XN Position */ +#define MPU_RASR_XN_Msk (1UL << MPU_RASR_XN_Pos) /*!< MPU RASR: ATTRS.XN Mask */ + +#define MPU_RASR_AP_Pos 24U /*!< MPU RASR: ATTRS.AP Position */ +#define MPU_RASR_AP_Msk (0x7UL << MPU_RASR_AP_Pos) /*!< MPU RASR: ATTRS.AP Mask */ + +#define MPU_RASR_TEX_Pos 19U /*!< MPU RASR: ATTRS.TEX Position */ +#define MPU_RASR_TEX_Msk (0x7UL << MPU_RASR_TEX_Pos) /*!< MPU RASR: ATTRS.TEX Mask */ + +#define MPU_RASR_S_Pos 18U /*!< MPU RASR: ATTRS.S Position */ +#define MPU_RASR_S_Msk (1UL << MPU_RASR_S_Pos) /*!< MPU RASR: ATTRS.S Mask */ + +#define MPU_RASR_C_Pos 17U /*!< MPU RASR: ATTRS.C Position */ +#define MPU_RASR_C_Msk (1UL << MPU_RASR_C_Pos) /*!< MPU RASR: ATTRS.C Mask */ + +#define MPU_RASR_B_Pos 16U /*!< MPU RASR: ATTRS.B Position */ +#define MPU_RASR_B_Msk (1UL << MPU_RASR_B_Pos) /*!< MPU RASR: ATTRS.B Mask */ + +#define MPU_RASR_SRD_Pos 8U /*!< MPU RASR: Sub-Region Disable Position */ +#define MPU_RASR_SRD_Msk (0xFFUL << MPU_RASR_SRD_Pos) /*!< MPU RASR: Sub-Region Disable Mask */ + +#define MPU_RASR_SIZE_Pos 1U /*!< MPU RASR: Region Size Field Position */ +#define MPU_RASR_SIZE_Msk (0x1FUL << MPU_RASR_SIZE_Pos) /*!< MPU RASR: Region Size Field Mask */ + +#define MPU_RASR_ENABLE_Pos 0U /*!< MPU RASR: Region enable bit Position */ +#define MPU_RASR_ENABLE_Msk (1UL /*<< MPU_RASR_ENABLE_Pos*/) /*!< MPU RASR: Region enable bit Disable Mask */ + +/*@} end of group CMSIS_MPU */ +#endif + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Type definitions for the Core Debug Registers + @{ + */ + +/** + \brief Structure type to access the Core Debug Register (CoreDebug). + */ +typedef struct +{ + __IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */ + __OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */ + __IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */ + __IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */ +} CoreDebug_Type; + +/* Debug Halting Control and Status Register Definitions */ +#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */ +#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */ + +#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */ +#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */ + +#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */ +#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */ + +#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */ +#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */ + +#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */ +#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */ + +#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */ +#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */ + +#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */ +#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */ + +#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */ +#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */ + +#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */ +#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */ + +#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */ +#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */ + +#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */ +#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */ + +#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */ +#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */ + +/* Debug Core Register Selector Register Definitions */ +#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */ +#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */ + +#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */ +#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */ + +/* Debug Exception and Monitor Control Register Definitions */ +#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */ +#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */ + +#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */ +#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */ + +#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */ +#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */ + +#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */ +#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */ + +#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */ +#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */ + +#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */ +#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */ + +#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */ +#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */ + +#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */ +#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */ + +#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */ +#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */ + +#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */ +#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */ + +#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */ +#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */ + +#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */ +#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */ + +#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */ +#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */ + +/*@} end of group CMSIS_CoreDebug */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_bitfield Core register bit field macros + \brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk). + @{ + */ + +/** + \brief Mask and shift a bit field value for use in a register bit range. + \param[in] field Name of the register bit field. + \param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type. + \return Masked and shifted value. +*/ +#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk) + +/** + \brief Mask and shift a register value to extract a bit filed value. + \param[in] field Name of the register bit field. + \param[in] value Value of register. This parameter is interpreted as an uint32_t type. + \return Masked and shifted bit field value. +*/ +#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos) + +/*@} end of group CMSIS_core_bitfield */ + + +/** + \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Core Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */ +#define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */ +#define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */ +#define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */ +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ +#define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */ +#define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */ +#define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */ +#define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE) /*!< Core Debug configuration struct */ + +#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) + #define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */ + #define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */ +#endif + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Debug Functions + - Core Register Access Functions + ******************************************************************************/ +/** + \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +#ifdef CMSIS_NVIC_VIRTUAL + #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE + #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h" + #endif + #include CMSIS_NVIC_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping + #define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping + #define NVIC_EnableIRQ __NVIC_EnableIRQ + #define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ + #define NVIC_DisableIRQ __NVIC_DisableIRQ + #define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ + #define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ + #define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ + #define NVIC_GetActive __NVIC_GetActive + #define NVIC_SetPriority __NVIC_SetPriority + #define NVIC_GetPriority __NVIC_GetPriority + #define NVIC_SystemReset __NVIC_SystemReset +#endif /* CMSIS_NVIC_VIRTUAL */ + +#ifdef CMSIS_VECTAB_VIRTUAL + #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE + #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h" + #endif + #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE +#else + #define NVIC_SetVector __NVIC_SetVector + #define NVIC_GetVector __NVIC_GetVector +#endif /* (CMSIS_VECTAB_VIRTUAL) */ + +#define NVIC_USER_IRQ_OFFSET 16 + + +/* The following EXC_RETURN values are saved the LR on exception entry */ +#define EXC_RETURN_HANDLER (0xFFFFFFF1UL) /* return to Handler mode, uses MSP after return */ +#define EXC_RETURN_THREAD_MSP (0xFFFFFFF9UL) /* return to Thread mode, uses MSP after return */ +#define EXC_RETURN_THREAD_PSP (0xFFFFFFFDUL) /* return to Thread mode, uses PSP after return */ + + +/** + \brief Set Priority Grouping + \details Sets the priority grouping field using the required unlock sequence. + The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field. + Only values from 0..7 are used. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Priority grouping field. + */ +__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup) +{ + uint32_t reg_value; + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + + reg_value = SCB->AIRCR; /* read old register configuration */ + reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */ + reg_value = (reg_value | + ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) ); /* Insert write key and priority group */ + SCB->AIRCR = reg_value; +} + + +/** + \brief Get Priority Grouping + \details Reads the priority grouping field from the NVIC Interrupt Controller. + \return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field). + */ +__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void) +{ + return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos)); +} + + +/** + \brief Enable Interrupt + \details Enables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + __COMPILER_BARRIER(); + NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __COMPILER_BARRIER(); + } +} + + +/** + \brief Get Interrupt Enable status + \details Returns a device specific interrupt enable status from the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt is not enabled. + \return 1 Interrupt is enabled. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Disable Interrupt + \details Disables a device specific interrupt in the NVIC interrupt controller. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + __DSB(); + __ISB(); + } +} + + +/** + \brief Get Pending Interrupt + \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Pending Interrupt + \details Sets the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Clear Pending Interrupt + \details Clears the pending bit of a device specific interrupt in the NVIC pending register. + \param [in] IRQn Device specific interrupt number. + \note IRQn must not be negative. + */ +__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); + } +} + + +/** + \brief Get Active Interrupt + \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt. + \param [in] IRQn Device specific interrupt number. + \return 0 Interrupt status is not active. + \return 1 Interrupt status is active. + \note IRQn must not be negative. + */ +__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn) +{ + if ((int32_t)(IRQn) >= 0) + { + return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL)); + } + else + { + return(0U); + } +} + + +/** + \brief Set Interrupt Priority + \details Sets the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + \note The priority cannot be set for every processor exception. + */ +__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if ((int32_t)(IRQn) >= 0) + { + NVIC->IP[((uint32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } + else + { + SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL); + } +} + + +/** + \brief Get Interrupt Priority + \details Reads the priority of a device specific interrupt or a processor exception. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Interrupt Priority. + Value is aligned automatically to the implemented priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn) +{ + + if ((int32_t)(IRQn) >= 0) + { + return(((uint32_t)NVIC->IP[((uint32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS))); + } + else + { + return(((uint32_t)SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS))); + } +} + + +/** + \brief Encode Priority + \details Encodes the priority for an interrupt with the given priority group, + preemptive priority value, and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set. + \param [in] PriorityGroup Used priority group. + \param [in] PreemptPriority Preemptive priority value (starting from 0). + \param [in] SubPriority Subpriority value (starting from 0). + \return Encoded priority. Value can be used in the function \ref NVIC_SetPriority(). + */ +__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + return ( + ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) | + ((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL))) + ); +} + + +/** + \brief Decode Priority + \details Decodes an interrupt priority value with a given priority group to + preemptive priority value and subpriority value. + In case of a conflict between priority grouping and available + priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set. + \param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority(). + \param [in] PriorityGroup Used priority group. + \param [out] pPreemptPriority Preemptive priority value (starting from 0). + \param [out] pSubPriority Subpriority value (starting from 0). + */ +__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority) +{ + uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */ + uint32_t PreemptPriorityBits; + uint32_t SubPriorityBits; + + PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp); + SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS)); + + *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL); + *pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL); +} + + +/** + \brief Set Interrupt Vector + \details Sets an interrupt vector in SRAM based interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + VTOR must been relocated to SRAM before. + \param [in] IRQn Interrupt number + \param [in] vector Address of interrupt handler function + */ +__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector; + /* ARM Application Note 321 states that the M3 does not require the architectural barrier */ +} + + +/** + \brief Get Interrupt Vector + \details Reads an interrupt vector from interrupt vector table. + The interrupt number can be positive to specify a device specific interrupt, + or negative to specify a processor exception. + \param [in] IRQn Interrupt number. + \return Address of interrupt handler function + */ +__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t vectors = (uint32_t )SCB->VTOR; + return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)); +} + + +/** + \brief System Reset + \details Initiates a system reset request to reset the MCU. + */ +__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) | + (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) | + SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */ + __DSB(); /* Ensure completion of memory access */ + + for(;;) /* wait until reset */ + { + __NOP(); + } +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + +/* ########################## FPU functions #################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_FpuFunctions FPU Functions + \brief Function that provides FPU type. + @{ + */ + +/** + \brief get FPU type + \details returns the FPU type + \returns + - \b 0: No FPU + - \b 1: Single precision FPU + - \b 2: Double + Single precision FPU + */ +__STATIC_INLINE uint32_t SCB_GetFPUType(void) +{ + return 0U; /* No FPU */ +} + + +/*@} end of CMSIS_Core_FpuFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) + +/** + \brief System Tick Configuration + \details Initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + \param [in] ticks Number of ticks between two interrupts. + \return 0 Function succeeded. + \return 1 Function failed. + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) + { + return (1UL); /* Reload value impossible */ + } + + SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0UL; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0UL); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + +/* ##################################### Debug In/Output function ########################################### */ +/** + \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_core_DebugFunctions ITM Functions + \brief Functions that access the ITM debug interface. + @{ + */ + +extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */ +#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */ + + +/** + \brief ITM Send Character + \details Transmits a character via the ITM channel 0, and + \li Just returns when no debugger is connected that has booked the output. + \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted. + \param [in] ch Character to transmit. + \returns Character to transmit. + */ +__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch) +{ + if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */ + ((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */ + { + while (ITM->PORT[0U].u32 == 0UL) + { + __NOP(); + } + ITM->PORT[0U].u8 = (uint8_t)ch; + } + return (ch); +} + + +/** + \brief ITM Receive Character + \details Inputs a character via the external variable \ref ITM_RxBuffer. + \return Received character. + \return -1 No character pending. + */ +__STATIC_INLINE int32_t ITM_ReceiveChar (void) +{ + int32_t ch = -1; /* no character available */ + + if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) + { + ch = ITM_RxBuffer; + ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */ + } + + return (ch); +} + + +/** + \brief ITM Check Character + \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer. + \return 0 No character available. + \return 1 Character available. + */ +__STATIC_INLINE int32_t ITM_CheckChar (void) +{ + + if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY) + { + return (0); /* no character available */ + } + else + { + return (1); /* character available */ + } +} + +/*@} end of CMSIS_core_DebugFunctions */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* __CORE_SC300_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv7.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv7.h new file mode 100644 index 0000000000..66ef59b4a0 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv7.h @@ -0,0 +1,272 @@ +/****************************************************************************** + * @file mpu_armv7.h + * @brief CMSIS MPU API for Armv7-M MPU + * @version V5.1.0 + * @date 08. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2017-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef ARM_MPU_ARMV7_H +#define ARM_MPU_ARMV7_H + +#define ARM_MPU_REGION_SIZE_32B ((uint8_t)0x04U) ///!< MPU Region Size 32 Bytes +#define ARM_MPU_REGION_SIZE_64B ((uint8_t)0x05U) ///!< MPU Region Size 64 Bytes +#define ARM_MPU_REGION_SIZE_128B ((uint8_t)0x06U) ///!< MPU Region Size 128 Bytes +#define ARM_MPU_REGION_SIZE_256B ((uint8_t)0x07U) ///!< MPU Region Size 256 Bytes +#define ARM_MPU_REGION_SIZE_512B ((uint8_t)0x08U) ///!< MPU Region Size 512 Bytes +#define ARM_MPU_REGION_SIZE_1KB ((uint8_t)0x09U) ///!< MPU Region Size 1 KByte +#define ARM_MPU_REGION_SIZE_2KB ((uint8_t)0x0AU) ///!< MPU Region Size 2 KBytes +#define ARM_MPU_REGION_SIZE_4KB ((uint8_t)0x0BU) ///!< MPU Region Size 4 KBytes +#define ARM_MPU_REGION_SIZE_8KB ((uint8_t)0x0CU) ///!< MPU Region Size 8 KBytes +#define ARM_MPU_REGION_SIZE_16KB ((uint8_t)0x0DU) ///!< MPU Region Size 16 KBytes +#define ARM_MPU_REGION_SIZE_32KB ((uint8_t)0x0EU) ///!< MPU Region Size 32 KBytes +#define ARM_MPU_REGION_SIZE_64KB ((uint8_t)0x0FU) ///!< MPU Region Size 64 KBytes +#define ARM_MPU_REGION_SIZE_128KB ((uint8_t)0x10U) ///!< MPU Region Size 128 KBytes +#define ARM_MPU_REGION_SIZE_256KB ((uint8_t)0x11U) ///!< MPU Region Size 256 KBytes +#define ARM_MPU_REGION_SIZE_512KB ((uint8_t)0x12U) ///!< MPU Region Size 512 KBytes +#define ARM_MPU_REGION_SIZE_1MB ((uint8_t)0x13U) ///!< MPU Region Size 1 MByte +#define ARM_MPU_REGION_SIZE_2MB ((uint8_t)0x14U) ///!< MPU Region Size 2 MBytes +#define ARM_MPU_REGION_SIZE_4MB ((uint8_t)0x15U) ///!< MPU Region Size 4 MBytes +#define ARM_MPU_REGION_SIZE_8MB ((uint8_t)0x16U) ///!< MPU Region Size 8 MBytes +#define ARM_MPU_REGION_SIZE_16MB ((uint8_t)0x17U) ///!< MPU Region Size 16 MBytes +#define ARM_MPU_REGION_SIZE_32MB ((uint8_t)0x18U) ///!< MPU Region Size 32 MBytes +#define ARM_MPU_REGION_SIZE_64MB ((uint8_t)0x19U) ///!< MPU Region Size 64 MBytes +#define ARM_MPU_REGION_SIZE_128MB ((uint8_t)0x1AU) ///!< MPU Region Size 128 MBytes +#define ARM_MPU_REGION_SIZE_256MB ((uint8_t)0x1BU) ///!< MPU Region Size 256 MBytes +#define ARM_MPU_REGION_SIZE_512MB ((uint8_t)0x1CU) ///!< MPU Region Size 512 MBytes +#define ARM_MPU_REGION_SIZE_1GB ((uint8_t)0x1DU) ///!< MPU Region Size 1 GByte +#define ARM_MPU_REGION_SIZE_2GB ((uint8_t)0x1EU) ///!< MPU Region Size 2 GBytes +#define ARM_MPU_REGION_SIZE_4GB ((uint8_t)0x1FU) ///!< MPU Region Size 4 GBytes + +#define ARM_MPU_AP_NONE 0U ///!< MPU Access Permission no access +#define ARM_MPU_AP_PRIV 1U ///!< MPU Access Permission privileged access only +#define ARM_MPU_AP_URO 2U ///!< MPU Access Permission unprivileged access read-only +#define ARM_MPU_AP_FULL 3U ///!< MPU Access Permission full access +#define ARM_MPU_AP_PRO 5U ///!< MPU Access Permission privileged access read-only +#define ARM_MPU_AP_RO 6U ///!< MPU Access Permission read-only access + +/** MPU Region Base Address Register Value +* +* \param Region The region to be configured, number 0 to 15. +* \param BaseAddress The base address for the region. +*/ +#define ARM_MPU_RBAR(Region, BaseAddress) \ + (((BaseAddress) & MPU_RBAR_ADDR_Msk) | \ + ((Region) & MPU_RBAR_REGION_Msk) | \ + (MPU_RBAR_VALID_Msk)) + +/** +* MPU Memory Access Attributes +* +* \param TypeExtField Type extension field, allows you to configure memory access type, for example strongly ordered, peripheral. +* \param IsShareable Region is shareable between multiple bus masters. +* \param IsCacheable Region is cacheable, i.e. its value may be kept in cache. +* \param IsBufferable Region is bufferable, i.e. using write-back caching. Cacheable but non-bufferable regions use write-through policy. +*/ +#define ARM_MPU_ACCESS_(TypeExtField, IsShareable, IsCacheable, IsBufferable) \ + ((((TypeExtField) << MPU_RASR_TEX_Pos) & MPU_RASR_TEX_Msk) | \ + (((IsShareable) << MPU_RASR_S_Pos) & MPU_RASR_S_Msk) | \ + (((IsCacheable) << MPU_RASR_C_Pos) & MPU_RASR_C_Msk) | \ + (((IsBufferable) << MPU_RASR_B_Pos) & MPU_RASR_B_Msk)) + +/** +* MPU Region Attribute and Size Register Value +* +* \param DisableExec Instruction access disable bit, 1= disable instruction fetches. +* \param AccessPermission Data access permissions, allows you to configure read/write access for User and Privileged mode. +* \param AccessAttributes Memory access attribution, see \ref ARM_MPU_ACCESS_. +* \param SubRegionDisable Sub-region disable field. +* \param Size Region size of the region to be configured, for example 4K, 8K. +*/ +#define ARM_MPU_RASR_EX(DisableExec, AccessPermission, AccessAttributes, SubRegionDisable, Size) \ + ((((DisableExec) << MPU_RASR_XN_Pos) & MPU_RASR_XN_Msk) | \ + (((AccessPermission) << MPU_RASR_AP_Pos) & MPU_RASR_AP_Msk) | \ + (((AccessAttributes) & (MPU_RASR_TEX_Msk | MPU_RASR_S_Msk | MPU_RASR_C_Msk | MPU_RASR_B_Msk))) | \ + (((SubRegionDisable) << MPU_RASR_SRD_Pos) & MPU_RASR_SRD_Msk) | \ + (((Size) << MPU_RASR_SIZE_Pos) & MPU_RASR_SIZE_Msk) | \ + (((MPU_RASR_ENABLE_Msk)))) + +/** +* MPU Region Attribute and Size Register Value +* +* \param DisableExec Instruction access disable bit, 1= disable instruction fetches. +* \param AccessPermission Data access permissions, allows you to configure read/write access for User and Privileged mode. +* \param TypeExtField Type extension field, allows you to configure memory access type, for example strongly ordered, peripheral. +* \param IsShareable Region is shareable between multiple bus masters. +* \param IsCacheable Region is cacheable, i.e. its value may be kept in cache. +* \param IsBufferable Region is bufferable, i.e. using write-back caching. Cacheable but non-bufferable regions use write-through policy. +* \param SubRegionDisable Sub-region disable field. +* \param Size Region size of the region to be configured, for example 4K, 8K. +*/ +#define ARM_MPU_RASR(DisableExec, AccessPermission, TypeExtField, IsShareable, IsCacheable, IsBufferable, SubRegionDisable, Size) \ + ARM_MPU_RASR_EX(DisableExec, AccessPermission, ARM_MPU_ACCESS_(TypeExtField, IsShareable, IsCacheable, IsBufferable), SubRegionDisable, Size) + +/** +* MPU Memory Access Attribute for strongly ordered memory. +* - TEX: 000b +* - Shareable +* - Non-cacheable +* - Non-bufferable +*/ +#define ARM_MPU_ACCESS_ORDERED ARM_MPU_ACCESS_(0U, 1U, 0U, 0U) + +/** +* MPU Memory Access Attribute for device memory. +* - TEX: 000b (if shareable) or 010b (if non-shareable) +* - Shareable or non-shareable +* - Non-cacheable +* - Bufferable (if shareable) or non-bufferable (if non-shareable) +* +* \param IsShareable Configures the device memory as shareable or non-shareable. +*/ +#define ARM_MPU_ACCESS_DEVICE(IsShareable) ((IsShareable) ? ARM_MPU_ACCESS_(0U, 1U, 0U, 1U) : ARM_MPU_ACCESS_(2U, 0U, 0U, 0U)) + +/** +* MPU Memory Access Attribute for normal memory. +* - TEX: 1BBb (reflecting outer cacheability rules) +* - Shareable or non-shareable +* - Cacheable or non-cacheable (reflecting inner cacheability rules) +* - Bufferable or non-bufferable (reflecting inner cacheability rules) +* +* \param OuterCp Configures the outer cache policy. +* \param InnerCp Configures the inner cache policy. +* \param IsShareable Configures the memory as shareable or non-shareable. +*/ +#define ARM_MPU_ACCESS_NORMAL(OuterCp, InnerCp, IsShareable) ARM_MPU_ACCESS_((4U | (OuterCp)), IsShareable, ((InnerCp) & 2U), ((InnerCp) & 1U)) + +/** +* MPU Memory Access Attribute non-cacheable policy. +*/ +#define ARM_MPU_CACHEP_NOCACHE 0U + +/** +* MPU Memory Access Attribute write-back, write and read allocate policy. +*/ +#define ARM_MPU_CACHEP_WB_WRA 1U + +/** +* MPU Memory Access Attribute write-through, no write allocate policy. +*/ +#define ARM_MPU_CACHEP_WT_NWA 2U + +/** +* MPU Memory Access Attribute write-back, no write allocate policy. +*/ +#define ARM_MPU_CACHEP_WB_NWA 3U + + +/** +* Struct for a single MPU Region +*/ +typedef struct { + uint32_t RBAR; //!< The region base address register value (RBAR) + uint32_t RASR; //!< The region attribute and size register value (RASR) \ref MPU_RASR +} ARM_MPU_Region_t; + +/** Enable the MPU. +* \param MPU_Control Default access permissions for unconfigured regions. +*/ +__STATIC_INLINE void ARM_MPU_Enable(uint32_t MPU_Control) +{ + MPU->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk; +#ifdef SCB_SHCSR_MEMFAULTENA_Msk + SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk; +#endif + __DSB(); + __ISB(); +} + +/** Disable the MPU. +*/ +__STATIC_INLINE void ARM_MPU_Disable(void) +{ + __DMB(); +#ifdef SCB_SHCSR_MEMFAULTENA_Msk + SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk; +#endif + MPU->CTRL &= ~MPU_CTRL_ENABLE_Msk; +} + +/** Clear and disable the given MPU region. +* \param rnr Region number to be cleared. +*/ +__STATIC_INLINE void ARM_MPU_ClrRegion(uint32_t rnr) +{ + MPU->RNR = rnr; + MPU->RASR = 0U; +} + +/** Configure an MPU region. +* \param rbar Value for RBAR register. +* \param rsar Value for RSAR register. +*/ +__STATIC_INLINE void ARM_MPU_SetRegion(uint32_t rbar, uint32_t rasr) +{ + MPU->RBAR = rbar; + MPU->RASR = rasr; +} + +/** Configure the given MPU region. +* \param rnr Region number to be configured. +* \param rbar Value for RBAR register. +* \param rsar Value for RSAR register. +*/ +__STATIC_INLINE void ARM_MPU_SetRegionEx(uint32_t rnr, uint32_t rbar, uint32_t rasr) +{ + MPU->RNR = rnr; + MPU->RBAR = rbar; + MPU->RASR = rasr; +} + +/** Memcopy with strictly ordered memory access, e.g. for register targets. +* \param dst Destination data is copied to. +* \param src Source data is copied from. +* \param len Amount of data words to be copied. +*/ +__STATIC_INLINE void ARM_MPU_OrderedMemcpy(volatile uint32_t* dst, const uint32_t* __RESTRICT src, uint32_t len) +{ + uint32_t i; + for (i = 0U; i < len; ++i) + { + dst[i] = src[i]; + } +} + +/** Load the given number of MPU regions from a table. +* \param table Pointer to the MPU configuration table. +* \param cnt Amount of regions to be configured. +*/ +__STATIC_INLINE void ARM_MPU_Load(ARM_MPU_Region_t const* table, uint32_t cnt) +{ + const uint32_t rowWordSize = sizeof(ARM_MPU_Region_t)/4U; + while (cnt > MPU_TYPE_RALIASES) { + ARM_MPU_OrderedMemcpy(&(MPU->RBAR), &(table->RBAR), MPU_TYPE_RALIASES*rowWordSize); + table += MPU_TYPE_RALIASES; + cnt -= MPU_TYPE_RALIASES; + } + ARM_MPU_OrderedMemcpy(&(MPU->RBAR), &(table->RBAR), cnt*rowWordSize); +} + +#endif diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv8.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv8.h new file mode 100644 index 0000000000..0041d4dc6f --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/mpu_armv8.h @@ -0,0 +1,346 @@ +/****************************************************************************** + * @file mpu_armv8.h + * @brief CMSIS MPU API for Armv8-M and Armv8.1-M MPU + * @version V5.1.0 + * @date 08. March 2019 + ******************************************************************************/ +/* + * Copyright (c) 2017-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef ARM_MPU_ARMV8_H +#define ARM_MPU_ARMV8_H + +/** \brief Attribute for device memory (outer only) */ +#define ARM_MPU_ATTR_DEVICE ( 0U ) + +/** \brief Attribute for non-cacheable, normal memory */ +#define ARM_MPU_ATTR_NON_CACHEABLE ( 4U ) + +/** \brief Attribute for normal memory (outer and inner) +* \param NT Non-Transient: Set to 1 for non-transient data. +* \param WB Write-Back: Set to 1 to use write-back update policy. +* \param RA Read Allocation: Set to 1 to use cache allocation on read miss. +* \param WA Write Allocation: Set to 1 to use cache allocation on write miss. +*/ +#define ARM_MPU_ATTR_MEMORY_(NT, WB, RA, WA) \ + (((NT & 1U) << 3U) | ((WB & 1U) << 2U) | ((RA & 1U) << 1U) | (WA & 1U)) + +/** \brief Device memory type non Gathering, non Re-ordering, non Early Write Acknowledgement */ +#define ARM_MPU_ATTR_DEVICE_nGnRnE (0U) + +/** \brief Device memory type non Gathering, non Re-ordering, Early Write Acknowledgement */ +#define ARM_MPU_ATTR_DEVICE_nGnRE (1U) + +/** \brief Device memory type non Gathering, Re-ordering, Early Write Acknowledgement */ +#define ARM_MPU_ATTR_DEVICE_nGRE (2U) + +/** \brief Device memory type Gathering, Re-ordering, Early Write Acknowledgement */ +#define ARM_MPU_ATTR_DEVICE_GRE (3U) + +/** \brief Memory Attribute +* \param O Outer memory attributes +* \param I O == ARM_MPU_ATTR_DEVICE: Device memory attributes, else: Inner memory attributes +*/ +#define ARM_MPU_ATTR(O, I) (((O & 0xFU) << 4U) | (((O & 0xFU) != 0U) ? (I & 0xFU) : ((I & 0x3U) << 2U))) + +/** \brief Normal memory non-shareable */ +#define ARM_MPU_SH_NON (0U) + +/** \brief Normal memory outer shareable */ +#define ARM_MPU_SH_OUTER (2U) + +/** \brief Normal memory inner shareable */ +#define ARM_MPU_SH_INNER (3U) + +/** \brief Memory access permissions +* \param RO Read-Only: Set to 1 for read-only memory. +* \param NP Non-Privileged: Set to 1 for non-privileged memory. +*/ +#define ARM_MPU_AP_(RO, NP) (((RO & 1U) << 1U) | (NP & 1U)) + +/** \brief Region Base Address Register value +* \param BASE The base address bits [31:5] of a memory region. The value is zero extended. Effective address gets 32 byte aligned. +* \param SH Defines the Shareability domain for this memory region. +* \param RO Read-Only: Set to 1 for a read-only memory region. +* \param NP Non-Privileged: Set to 1 for a non-privileged memory region. +* \oaram XN eXecute Never: Set to 1 for a non-executable memory region. +*/ +#define ARM_MPU_RBAR(BASE, SH, RO, NP, XN) \ + ((BASE & MPU_RBAR_BASE_Msk) | \ + ((SH << MPU_RBAR_SH_Pos) & MPU_RBAR_SH_Msk) | \ + ((ARM_MPU_AP_(RO, NP) << MPU_RBAR_AP_Pos) & MPU_RBAR_AP_Msk) | \ + ((XN << MPU_RBAR_XN_Pos) & MPU_RBAR_XN_Msk)) + +/** \brief Region Limit Address Register value +* \param LIMIT The limit address bits [31:5] for this memory region. The value is one extended. +* \param IDX The attribute index to be associated with this memory region. +*/ +#define ARM_MPU_RLAR(LIMIT, IDX) \ + ((LIMIT & MPU_RLAR_LIMIT_Msk) | \ + ((IDX << MPU_RLAR_AttrIndx_Pos) & MPU_RLAR_AttrIndx_Msk) | \ + (MPU_RLAR_EN_Msk)) + +#if defined(MPU_RLAR_PXN_Pos) + +/** \brief Region Limit Address Register with PXN value +* \param LIMIT The limit address bits [31:5] for this memory region. The value is one extended. +* \param PXN Privileged execute never. Defines whether code can be executed from this privileged region. +* \param IDX The attribute index to be associated with this memory region. +*/ +#define ARM_MPU_RLAR_PXN(LIMIT, PXN, IDX) \ + ((LIMIT & MPU_RLAR_LIMIT_Msk) | \ + ((PXN << MPU_RLAR_PXN_Pos) & MPU_RLAR_PXN_Msk) | \ + ((IDX << MPU_RLAR_AttrIndx_Pos) & MPU_RLAR_AttrIndx_Msk) | \ + (MPU_RLAR_EN_Msk)) + +#endif + +/** +* Struct for a single MPU Region +*/ +typedef struct { + uint32_t RBAR; /*!< Region Base Address Register value */ + uint32_t RLAR; /*!< Region Limit Address Register value */ +} ARM_MPU_Region_t; + +/** Enable the MPU. +* \param MPU_Control Default access permissions for unconfigured regions. +*/ +__STATIC_INLINE void ARM_MPU_Enable(uint32_t MPU_Control) +{ + MPU->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk; +#ifdef SCB_SHCSR_MEMFAULTENA_Msk + SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk; +#endif + __DSB(); + __ISB(); +} + +/** Disable the MPU. +*/ +__STATIC_INLINE void ARM_MPU_Disable(void) +{ + __DMB(); +#ifdef SCB_SHCSR_MEMFAULTENA_Msk + SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk; +#endif + MPU->CTRL &= ~MPU_CTRL_ENABLE_Msk; +} + +#ifdef MPU_NS +/** Enable the Non-secure MPU. +* \param MPU_Control Default access permissions for unconfigured regions. +*/ +__STATIC_INLINE void ARM_MPU_Enable_NS(uint32_t MPU_Control) +{ + MPU_NS->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk; +#ifdef SCB_SHCSR_MEMFAULTENA_Msk + SCB_NS->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk; +#endif + __DSB(); + __ISB(); +} + +/** Disable the Non-secure MPU. +*/ +__STATIC_INLINE void ARM_MPU_Disable_NS(void) +{ + __DMB(); +#ifdef SCB_SHCSR_MEMFAULTENA_Msk + SCB_NS->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk; +#endif + MPU_NS->CTRL &= ~MPU_CTRL_ENABLE_Msk; +} +#endif + +/** Set the memory attribute encoding to the given MPU. +* \param mpu Pointer to the MPU to be configured. +* \param idx The attribute index to be set [0-7] +* \param attr The attribute value to be set. +*/ +__STATIC_INLINE void ARM_MPU_SetMemAttrEx(MPU_Type* mpu, uint8_t idx, uint8_t attr) +{ + const uint8_t reg = idx / 4U; + const uint32_t pos = ((idx % 4U) * 8U); + const uint32_t mask = 0xFFU << pos; + + if (reg >= (sizeof(mpu->MAIR) / sizeof(mpu->MAIR[0]))) { + return; // invalid index + } + + mpu->MAIR[reg] = ((mpu->MAIR[reg] & ~mask) | ((attr << pos) & mask)); +} + +/** Set the memory attribute encoding. +* \param idx The attribute index to be set [0-7] +* \param attr The attribute value to be set. +*/ +__STATIC_INLINE void ARM_MPU_SetMemAttr(uint8_t idx, uint8_t attr) +{ + ARM_MPU_SetMemAttrEx(MPU, idx, attr); +} + +#ifdef MPU_NS +/** Set the memory attribute encoding to the Non-secure MPU. +* \param idx The attribute index to be set [0-7] +* \param attr The attribute value to be set. +*/ +__STATIC_INLINE void ARM_MPU_SetMemAttr_NS(uint8_t idx, uint8_t attr) +{ + ARM_MPU_SetMemAttrEx(MPU_NS, idx, attr); +} +#endif + +/** Clear and disable the given MPU region of the given MPU. +* \param mpu Pointer to MPU to be used. +* \param rnr Region number to be cleared. +*/ +__STATIC_INLINE void ARM_MPU_ClrRegionEx(MPU_Type* mpu, uint32_t rnr) +{ + mpu->RNR = rnr; + mpu->RLAR = 0U; +} + +/** Clear and disable the given MPU region. +* \param rnr Region number to be cleared. +*/ +__STATIC_INLINE void ARM_MPU_ClrRegion(uint32_t rnr) +{ + ARM_MPU_ClrRegionEx(MPU, rnr); +} + +#ifdef MPU_NS +/** Clear and disable the given Non-secure MPU region. +* \param rnr Region number to be cleared. +*/ +__STATIC_INLINE void ARM_MPU_ClrRegion_NS(uint32_t rnr) +{ + ARM_MPU_ClrRegionEx(MPU_NS, rnr); +} +#endif + +/** Configure the given MPU region of the given MPU. +* \param mpu Pointer to MPU to be used. +* \param rnr Region number to be configured. +* \param rbar Value for RBAR register. +* \param rlar Value for RLAR register. +*/ +__STATIC_INLINE void ARM_MPU_SetRegionEx(MPU_Type* mpu, uint32_t rnr, uint32_t rbar, uint32_t rlar) +{ + mpu->RNR = rnr; + mpu->RBAR = rbar; + mpu->RLAR = rlar; +} + +/** Configure the given MPU region. +* \param rnr Region number to be configured. +* \param rbar Value for RBAR register. +* \param rlar Value for RLAR register. +*/ +__STATIC_INLINE void ARM_MPU_SetRegion(uint32_t rnr, uint32_t rbar, uint32_t rlar) +{ + ARM_MPU_SetRegionEx(MPU, rnr, rbar, rlar); +} + +#ifdef MPU_NS +/** Configure the given Non-secure MPU region. +* \param rnr Region number to be configured. +* \param rbar Value for RBAR register. +* \param rlar Value for RLAR register. +*/ +__STATIC_INLINE void ARM_MPU_SetRegion_NS(uint32_t rnr, uint32_t rbar, uint32_t rlar) +{ + ARM_MPU_SetRegionEx(MPU_NS, rnr, rbar, rlar); +} +#endif + +/** Memcopy with strictly ordered memory access, e.g. for register targets. +* \param dst Destination data is copied to. +* \param src Source data is copied from. +* \param len Amount of data words to be copied. +*/ +__STATIC_INLINE void ARM_MPU_OrderedMemcpy(volatile uint32_t* dst, const uint32_t* __RESTRICT src, uint32_t len) +{ + uint32_t i; + for (i = 0U; i < len; ++i) + { + dst[i] = src[i]; + } +} + +/** Load the given number of MPU regions from a table to the given MPU. +* \param mpu Pointer to the MPU registers to be used. +* \param rnr First region number to be configured. +* \param table Pointer to the MPU configuration table. +* \param cnt Amount of regions to be configured. +*/ +__STATIC_INLINE void ARM_MPU_LoadEx(MPU_Type* mpu, uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) +{ + const uint32_t rowWordSize = sizeof(ARM_MPU_Region_t)/4U; + if (cnt == 1U) { + mpu->RNR = rnr; + ARM_MPU_OrderedMemcpy(&(mpu->RBAR), &(table->RBAR), rowWordSize); + } else { + uint32_t rnrBase = rnr & ~(MPU_TYPE_RALIASES-1U); + uint32_t rnrOffset = rnr % MPU_TYPE_RALIASES; + + mpu->RNR = rnrBase; + while ((rnrOffset + cnt) > MPU_TYPE_RALIASES) { + uint32_t c = MPU_TYPE_RALIASES - rnrOffset; + ARM_MPU_OrderedMemcpy(&(mpu->RBAR)+(rnrOffset*2U), &(table->RBAR), c*rowWordSize); + table += c; + cnt -= c; + rnrOffset = 0U; + rnrBase += MPU_TYPE_RALIASES; + mpu->RNR = rnrBase; + } + + ARM_MPU_OrderedMemcpy(&(mpu->RBAR)+(rnrOffset*2U), &(table->RBAR), cnt*rowWordSize); + } +} + +/** Load the given number of MPU regions from a table. +* \param rnr First region number to be configured. +* \param table Pointer to the MPU configuration table. +* \param cnt Amount of regions to be configured. +*/ +__STATIC_INLINE void ARM_MPU_Load(uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) +{ + ARM_MPU_LoadEx(MPU, rnr, table, cnt); +} + +#ifdef MPU_NS +/** Load the given number of MPU regions from a table to the Non-secure MPU. +* \param rnr First region number to be configured. +* \param table Pointer to the MPU configuration table. +* \param cnt Amount of regions to be configured. +*/ +__STATIC_INLINE void ARM_MPU_Load_NS(uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) +{ + ARM_MPU_LoadEx(MPU_NS, rnr, table, cnt); +} +#endif + +#endif + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/tz_context.h b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/tz_context.h new file mode 100644 index 0000000000..0d09749f3a --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/CMSIS/Include/tz_context.h @@ -0,0 +1,70 @@ +/****************************************************************************** + * @file tz_context.h + * @brief Context Management for Armv8-M TrustZone + * @version V1.0.1 + * @date 10. January 2018 + ******************************************************************************/ +/* + * Copyright (c) 2017-2018 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#elif defined (__clang__) + #pragma clang system_header /* treat file as system include file */ +#endif + +#ifndef TZ_CONTEXT_H +#define TZ_CONTEXT_H + +#include + +#ifndef TZ_MODULEID_T +#define TZ_MODULEID_T +/// \details Data type that identifies secure software modules called by a process. +typedef uint32_t TZ_ModuleId_t; +#endif + +/// \details TZ Memory ID identifies an allocated memory slot. +typedef uint32_t TZ_MemoryId_t; + +/// Initialize secure context memory system +/// \return execution status (1: success, 0: error) +uint32_t TZ_InitContextSystem_S (void); + +/// Allocate context memory for calling secure software modules in TrustZone +/// \param[in] module identifies software modules called from non-secure mode +/// \return value != 0 id TrustZone memory slot identifier +/// \return value 0 no memory available or internal error +TZ_MemoryId_t TZ_AllocModuleContext_S (TZ_ModuleId_t module); + +/// Free context memory that was previously allocated with \ref TZ_AllocModuleContext_S +/// \param[in] id TrustZone memory slot identifier +/// \return execution status (1: success, 0: error) +uint32_t TZ_FreeModuleContext_S (TZ_MemoryId_t id); + +/// Load secure context (called on RTOS thread context switch) +/// \param[in] id TrustZone memory slot identifier +/// \return execution status (1: success, 0: error) +uint32_t TZ_LoadContext_S (TZ_MemoryId_t id); + +/// Store secure context (called on RTOS thread context switch) +/// \param[in] id TrustZone memory slot identifier +/// \return execution status (1: success, 0: error) +uint32_t TZ_StoreContext_S (TZ_MemoryId_t id); + +#endif // TZ_CONTEXT_H diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_adc.h b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_adc.h new file mode 100644 index 0000000000..1191f13973 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_adc.h @@ -0,0 +1,462 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef __HAL_ADC_H__ +#define __HAL_ADC_H__ + +#include "hal_common.h" + +/*! + * @addtogroup ADC + * @{ + */ + +/*! + * @brief ADC driver version number. + */ +#define ADC_DRIVER_VERSION 0u /*!< adc_0. */ + +/*! + * @addtogroup ADC_STATUS + * Define ADC status. + * @{ + */ + +#define ADC_STATUS_CONV_SLOT_DONE (1u << 0u) /*!< Status flag when ADC slot conversion done. */ +#define ADC_STATUS_CONV_SAMPLE_DONE (1u << 1u) /*!< Status flag when ADC sample done. */ +#define ADC_STATUS_CONV_SEQ_DONE (1u << 2u) /*!< Status flag when ADC sequence conversion done. */ +#define ADC_STATUS_COMPARE_DONE (1u << 3u) /*!< Status flag when ADC compare done. */ + +/*! + * @} + */ + +/*! + * @addtogroup ADC_INT + * ADC interrupt define. + * @{ + */ + +#define ADC_INT_CONV_SLOT_DONE (1u << 0u) /*!< Interrupt enable when when ADC slot conversion done. */ +#define ADC_INT_CONV_SAMPLE_DONE (1u << 1u) /*!< Interrupt enable when when ADC sample done. */ +#define ADC_INT_CONV_SEQ_DONE (1u << 2u) /*!< Interrupt enable when when ADC sequence conversion done. */ +#define ADC_INT_COMPARE_DONE (1u << 3u) /*!< Interrupt enable when when ADC compare done. */ + +/*! + * @} + */ + +/*! + * @addtogroup ADC_RESULT_FLAGS + * Define ADC Convert result flags. + * @{ + */ + +#define ADC_CONV_RESULT_FLAG_OVERRUN (1u << 0u) /*!< Result flag when adc conversion result is overrun. */ +#define ADC_CONV_RESULT_FLAG_VALID (1u << 1u) /*!< Result flag when adc conversion result valid. */ + +/*! + * @} + */ + +/*! + * @brief ADC Resolution type. + * + * Select ADC conversion valid data bit. + */ +typedef enum +{ + ADC_Resolution_12b = 0u, /*!< Resolution select 12 bit. */ + ADC_Resolution_11b = 1u, /*!< Resolution select 11 bit. */ + ADC_Resolution_10b = 2u, /*!< Resolution select 10 bit. */ + ADC_Resolution_9b = 3u, /*!< Resolution select 9 bit. */ + ADC_Resolution_8b = 4u, /*!< Resolution select 8 bit. */ +} ADC_Resolution_Type; + +/*! + * @brief ADC Prescaler type. + * + * Select the prescaler of the bus as the adc clock. + */ +typedef enum +{ + ADC_ClockDiv_2 = 0u, /*!< ADC clock divided by 2. */ + ADC_ClockDiv_3 = 1u, /*!< ADC clock divided by 3. */ + ADC_ClockDiv_4 = 2u, /*!< ADC clock divided by 4. */ + ADC_ClockDiv_5 = 3u, /*!< ADC clock divided by 5. */ + ADC_ClockDiv_6 = 4u, /*!< ADC clock divided by 6. */ + ADC_ClockDiv_7 = 5u, /*!< ADC clock divided by 7. */ + ADC_ClockDiv_8 = 6u, /*!< ADC clock divided by 8. */ + ADC_ClockDiv_9 = 7u, /*!< ADC clock divided by 9. */ + ADC_ClockDiv_10 = 8u, /*!< ADC clock divided by 10. */ + ADC_ClockDiv_11 = 9u, /*!< ADC clock divided by 11. */ + ADC_ClockDiv_12 = 10u, /*!< ADC clock divided by 12. */ + ADC_ClockDiv_13 = 11u, /*!< ADC clock divided by 13. */ + ADC_ClockDiv_14 = 12u, /*!< ADC clock divided by 14. */ + ADC_ClockDiv_15 = 13u, /*!< ADC clock divided by 15. */ + ADC_ClockDiv_16 = 14u, /*!< ADC clock divided by 16. */ + ADC_ClockDiv_17 = 15u, /*!< ADC clock divided by 17. */ +} ADC_ClockDiv_Type; + +/*! + * @brief ADC HwTrgEdge type. + * + * Use hardware trigger in ADC, select the trigger edge to trigger adc. + */ +typedef enum +{ + ADC_HwTrgEdge_Both = 0u, /*!< Both edge trigger. */ + ADC_HwTrgEdge_Falling = 1u, /*!< Falling edge trigger. */ + ADC_HwTrgEdge_Rising = 2u, /*!< Rising edge trigger. */ + ADC_HwTrgEdge_Disabled = 3u, /*!< Edge trigger is disabled. */ +} ADC_HwTrgEdge_Type; + +/*! + * @brief ADC HwTrgDelayCycle type. + * + * After the hardware trigger signal is generated, delay N PCLK2 clock cycles before starting the first sample. + */ +typedef enum +{ + ADC_HwTrgDelayCycle_0 = 0u, /*!< Delay 0 cycle. */ + ADC_HwTrgDelayCycle_4 = 1u, /*!< Delay 4 cycle. */ + ADC_HwTrgDelayCycle_16 = 2u, /*!< Delay 16 cycle. */ + ADC_HwTrgDelayCycle_32 = 3u, /*!< Delay 32 cycle. */ + ADC_HwTrgDelayCycle_64 = 4u, /*!< Delay 64 cycle. */ + ADC_HwTrgDelayCycle_128 = 5u, /*!< Delay 128 cycle. */ + ADC_HwTrgDelayCycle_256 = 6u, /*!< Delay 256 cycle. */ + ADC_HwTrgDelayCycle_512 = 7u, /*!< Delay 512 cycle. */ +} ADC_HwTrgDelayCycle_Type; + +/*! + * @brief ADC Align type. + * + * Choose to store the converted data as left-aligned or right-aligned. + */ +typedef enum +{ + ADC_Align_Right = 0u, /*!< Data right align. */ + ADC_Align_Left = 1u, /*!< Data left align. */ +} ADC_Align_Type; + +/*! + * @brief ADC RegularSeqDirection type. + * + * In single-cycle scan or continuous scan mode, set the order of scan channels. + */ +typedef enum +{ + ADC_RegSeqDirection_LowFirst = 0u, /*!< ADC scan direction from low channel to high channel. */ + ADC_RegSeqDirection_HighFirst = 1u, /*!< ADC scan direction from high channel to low channel. */ +} ADC_RegSeqDirection_Type; + +/*! + * @brief ADC ConvMode type. + * + * Select the adc channel or sequence convert mode. + */ +typedef enum +{ + ADC_ConvMode_SingleSlot = 0u, /*!< Run the conversion by channel. */ + ADC_ConvMode_Seq = 1u, /*!< Run the conversion by sequence. */ + ADC_ConvMode_SeqContinues = 2u, /*!< Run the conversion by sequence again and again. */ +} ADC_ConvMode_Type; + +/*! + * @brief ADC HwTrgSel type. + * + * Select ADC hardware trigger source. + */ +typedef enum +{ + ADC_HwTrgSource_Alt0 = 0u, /*!< source 0 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt1 = 1u, /*!< source 1 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt2 = 2u, /*!< source 2 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt3 = 3u, /*!< source 3 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt4 = 4u, /*!< source 4 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt5 = 5u, /*!< source 5 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt6 = 6u, /*!< source 6 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt7 = 7u, /*!< source 7 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt8 = 8u, /*!< source 8 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt9 = 9u, /*!< source 9 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt10 = 10u, /*!< source 10 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt11 = 11u, /*!< source 11 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt12 = 12u, /*!< source 12 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt13 = 13u, /*!< source 13 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt14 = 14u, /*!< source 14 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt15 = 15u, /*!< source 15 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt16 = 16u, /*!< source 16 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt17 = 17u, /*!< source 17 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt18 = 18u, /*!< source 18 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt19 = 19u, /*!< source 19 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt20 = 20u, /*!< source 20 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt21 = 21u, /*!< source 21 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt22 = 22u, /*!< source 22 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt23 = 23u, /*!< source 23 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt24 = 24u, /*!< source 24 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt25 = 25u, /*!< source 25 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt26 = 26u, /*!< source 26 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt27 = 27u, /*!< source 27 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt28 = 28u, /*!< source 28 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt29 = 29u, /*!< source 29 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt30 = 30u, /*!< source 30 as an external trigger source for ADC . */ + ADC_HwTrgSource_Alt31 = 31u, /*!< source 31 as an external trigger source for ADC . */ +} ADC_HwTrgSource_Type; + +/*! + * @brief ADC SampleTime type. + * + * Select channel sample time. + */ +typedef enum +{ + ADC_SampleTime_Alt0 = 0u, /*!< Channel sample time mode 0 . */ + ADC_SampleTime_Alt1 = 1u, /*!< Channel sample time mode 1 . */ + ADC_SampleTime_Alt2 = 2u, /*!< Channel sample time mode 2 . */ + ADC_SampleTime_Alt3 = 3u, /*!< Channel sample time mode 3 . */ + ADC_SampleTime_Alt4 = 4u, /*!< Channel sample time mode 4 . */ + ADC_SampleTime_Alt5 = 5u, /*!< Channel sample time mode 5 . */ + ADC_SampleTime_Alt6 = 6u, /*!< Channel sample time mode 6 . */ + ADC_SampleTime_Alt7 = 7u, /*!< Channel sample time mode 7 . */ + ADC_SampleTime_Alt8 = 8u, /*!< Channel sample time mode 8 . */ + ADC_SampleTime_Alt9 = 9u, /*!< Channel sample time mode 9 . */ + ADC_SampleTime_Alt10 = 10u, /*!< Channel sample time mode 10. */ + ADC_SampleTime_Alt11 = 11u, /*!< Channel sample time mode 11. */ + ADC_SampleTime_Alt12 = 12u, /*!< Channel sample time mode 12. */ + ADC_SampleTime_Alt13 = 13u, /*!< Channel sample time mode 13. */ + ADC_SampleTime_Alt14 = 14u, /*!< Channel sample time mode 14. */ + ADC_SampleTime_Alt15 = 15u, /*!< Channel sample time mode 15. */ +} ADC_SampleTime_Type; + +/*! + * @brief This type of structure instance is used to keep the settings + * when calling the @ref ADC_Init() to initialize the ADC module. + */ +typedef struct +{ + ADC_Resolution_Type Resolution; /*!< Specify the available bits for the conversion result data. */ + ADC_ClockDiv_Type ClockDiv; /*!< Specify the adc clock divison. */ + ADC_Align_Type Align; /*!< Specify the data alignment. */ + ADC_ConvMode_Type ConvMode; /*!< Specify the adc conversion mode. */ +} ADC_Init_Type; + +/*! + * @brief This type of structure instance is used to keep the settings + * when calling the @ref ADC_EnableHwTrigger() to initialize the ADC hardware trigger module. + */ +typedef struct +{ + ADC_HwTrgSource_Type Source; /*!< Select the ADC hardware trigger source. */ + ADC_HwTrgEdge_Type Edge; /*!< Select the trigger edge. */ + ADC_HwTrgDelayCycle_Type DelayCycle; /*!< Select the hardware trigger shift sample. */ +} ADC_HwTrgConf_Type; + +/*! + * @brief This type of structure instance is used to keep the settings + * when calling the @ref ADC_EnableRegSeq() to initialize the ADC regular sequence module. + */ +typedef struct +{ + uint32_t SeqSlots; /*!< Select the slots length. */ + ADC_RegSeqDirection_Type SeqDirection; /*!< Select the regular sequence sacn direction. */ +} ADC_RegSeqConf_Type; + +/*! + * @brief This type of structure instance is used to keep the settings + * when calling the @ref ADC_EnableAnySeq() to initialize the ADC Any sequence mode. + */ +typedef struct +{ + uint32_t SeqLen; /*!< Select the slots length. */ + uint32_t * SeqChannels; /*!< Select the channel, channel can be disorder. */ +} ADC_AnySeqConf_Type; + + +/*! + * @brief This type of structure instance is used to keep the settings + * when calling the @ref ADC_EnableHwCompare() to enable the ADC windows compare mode. + */ +typedef struct +{ + uint32_t ChnNum; /*!< Select the channel number binding to the compare. */ + uint32_t HighLimit; /*!< The comparator high limit. */ + uint32_t LowLimit; /*!< The comparator low limit. */ +} ADC_HwCompConf_Type; + +/*! + * @brief Initialize the ADC module. + * + * @param ADCx ADC instance. + * @param init Pointer to the initialization structure. See to @ref ADC_Init_Type. + * @return None. + */ +void ADC_Init(ADC_Type * ADCx, ADC_Init_Type * init); + +/*! + * @brief Enable the ADC module. + * + * The ADC module should be enabled before conversion data. + * + * @param ADCx ADC instance. + * @param enable 'true' to enable the module, 'false' to disable the module. + * @return None. + */ +void ADC_Enable(ADC_Type * ADCx, bool enable); + +/*! + * @brief Enable Temperature sensor from the ADC module. + * + * The module should be enabled when Using the built-in temperature sensor to + * detect temperature changes inside the device. + * + * @param ADCx ADC instance. + * @param enable 'true' to enable the module, 'false' to disable the module. + * @return None. + */ +void ADC_EnableTempSensor(ADC_Type * ADCx, bool enable); + +/*! + * @brief Enable Voltage sensor from the ADC module. + * + * The module should be enabled when using internal reference voltage . + * + * @param ADCx ADC instance. + * @param enable 'true' to enable the module, 'false' to disable the module. + * @return None. + */ +void ADC_EnableVoltSensor(ADC_Type * ADCx, bool enable); + +/*! + * @brief Enable the DMA from the ADC module. + * + * @param ADCx ADC instance. + * @param enable 'true' to enable the DMA, 'false' to disable the DMA. + * @return None. + */ +void ADC_EnableDMA(ADC_Type * ADCx, bool enable); + +/*! + * @brief Enable interrupts of the ADC module. + * + * @param ADCx ADC instance. + * @param interrupts Interrupt code masks. + * @param enable 'true' to enable the indicated interrupts, 'false' to disable the indicated interrupts. + * @return None. + */ +void ADC_EnableInterrupts(ADC_Type * ADCx, uint32_t interrupts, bool enable); + +/*! + * @brief Get the current status flags of the ADC module. + * + * @param ADCx ADC instance. + * @return Status flags. + */ +uint32_t ADC_GetStatus(ADC_Type * ADCx); + +/*! + * @brief Clear the status flags of the ADC module. + * + * @param ADCx ADC instance. + * @param flags The mask codes of the indicated interrupt flags to be cleared. + * @return None. + */ +void ADC_ClearStatus(ADC_Type * ADCx, uint32_t flags); + +/*! + * @brief Get the channel convert data from the ADC module. + * + * @param ADCx ADC instance. + * @param channel The convert channel. + * @param flags The ADC convert result flags. See to @ref ADC_RESULT_FLAGS. + * @return The data value. + */ +uint32_t ADC_GetConvResult(ADC_Type * ADCx, uint32_t * channel, uint32_t * flags); + +/*! + * @brief Get the indication channel current data from the ADC module. + * + * @param ADCx ADC instance. + * @param channel the adc channel. + * @param flags The ADC convert result flags. See to @ref ADC_RESULT_FLAGS. + * @return The data value. + */ +uint32_t ADC_GetChnConvResult(ADC_Type * ADCx, uint32_t channel, uint32_t * flags); + + +/*! + * @brief Configuration channel sample time of the ADC module. + * + * @param ADCx ADC instance. + * @param channel the adc convert channel. + * @param sampletime the adc channel sample time + * @return None. + */ +void ADC_SetChnSampleTime(ADC_Type * ADCx, uint32_t channel, ADC_SampleTime_Type sampletime); + +/*! + * @brief Enable regular sequence from the ADC module. + * + * The ADC module should be enabled before regular sequence function. + * it also have interrupt. + * + * @param ADCx ADC instance. + * @param conf Pointer to the initialization structure. See to @ref ADC_RegSeqConf_Type. + * @return None. + */ +void ADC_EnableRegSeq(ADC_Type * ADCx, ADC_RegSeqConf_Type * conf); + +/*! + * @brief Enable hardware trigger from the ADC module. + * + * The ADC module should be enabled before using hardware trrigger function. + * it also have interrupt. + * + * @param ADCx ADC instance. + * @param conf Select the hardware trigger source. See to @ref ADC_HwTrgConf_Type. + * @return None. + */ +void ADC_EnableHwTrigger(ADC_Type * ADCx, ADC_HwTrgConf_Type * conf); + +/*! + * @brief Enable Any sequence from the ADC module. + * + * The ADC module should be enabled before Any sequence function. + * it also have interrupt. + * + * @param ADCx ADC instance. + * @param conf Pointer to the initialization structure. See to @ref ADC_AnySeqConf_Type. + * @return None. + */ +void ADC_EnableAnySeq(ADC_Type * ADCx, ADC_AnySeqConf_Type * conf); + +/*! + * @brief Enable window comparison from the ADC module. + * + * The ADC module should be enabled before using analog watchdog function. + * it also have interrupt. + * + * @param ADCx ADC instance. + * @param conf Pointer to the initialization structure. See to @ref ADC_HwCompareConf_Type. + * @return None. + */ +void ADC_EnableHwComp(ADC_Type * ADCx, ADC_HwCompConf_Type * conf); + +/*! + * @brief Do soft trigger. + * + * @param ADCx ADC instance. + * @param enable 'true' to enable the ADC start convert, 'false' to disable. + * @return None. + */ +void ADC_DoSwTrigger(ADC_Type * ADCx, bool enable); + +/*! + *@} + */ + +#endif /*__HAL_ADC_H__. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_common.h b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_common.h new file mode 100644 index 0000000000..5af1b3b184 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_common.h @@ -0,0 +1,17 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef __HAL_COMMON_H__ +#define __HAL_COMMON_H__ + +#include +#include +#include + +#include "hal_device_registers.h" + +#endif /* __HAL_COMMON_H__ */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_comp.h b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_comp.h new file mode 100644 index 0000000000..cfee36a120 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_comp.h @@ -0,0 +1,261 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef __HAL_COMP_H__ +#define __HAL_COMP_H__ + +#include "hal_common.h" + +/*! + * @addtogroup COMP + * @{ + */ + +/*! + * @brief COMP driver version number. + */ +#define COMP_DRIVER_VERSION 0u /*!< COMP_0. */ + +/*! + * @brief COMP number. + */ +#define COMP_CHANNEL_NUM 2 + +/*! + * @brief COMP output filter type. + * + * If the compare result keeps n APB Clocks unchanged, the output is valid. + */ +typedef enum +{ + COMP_OutFilter_1 = 0, /*!< 1 PCLK filter. */ + COMP_OutFilter_2 = 1, /*!< 2 PCLK filter. */ + COMP_OutFilter_4 = 2, /*!< 4 PCLK filter. */ + COMP_OutFilter_8 = 3, /*!< 8 PCLK filter. */ + COMP_OutFilter_16 = 4, /*!< 16 PCLK filter. */ + COMP_OutFilter_32 = 5, /*!< 32 PCLK filter. */ + COMP_OutFilter_64 = 6, /*!< 64 PCLK filter. */ + COMP_OutFilter_128 = 7, /*!< 128 PCLK filter. */ +} COMP_OutFilter_Type; + +/*! + * @brief COMP hysteresis type. + * + * If V(InvInput) > V(PosInput), the compare result is high, if V(InvInput) < (V(PosInput) - hysteresis), the compare result is low. + */ +typedef enum +{ + COMP_Hysteresis_Alt0 = 0, /*!< Hysteresis Alt 0. */ + COMP_Hysteresis_Alt1 = 1, /*!< Hysteresis Alt 1. */ + COMP_Hysteresis_Alt2 = 2, /*!< Hysteresis Alt 2. */ + COMP_Hysteresis_Alt3 = 3, /*!< Hysteresis Alt 3. */ +} COMP_Hysteresis_Type; + +/*! + * @brief COMP output mux type. + */ +typedef enum +{ + COMP_OutMux_None = 0, /*!< Not output to other peripheral input. */ + COMP_OutMux_Alt0 = 2, /*!< Output Mux 0. */ + COMP_OutMux_Alt1 = 4, /*!< Output Mux 1. */ + COMP_OutMux_Alt2 = 6, /*!< Output Mux 2. */ + COMP_OutMux_Alt3 = 7, /*!< Output Mux 3. */ + COMP_OutMux_Alt4 = 8, /*!< Output Mux 4. */ + COMP_OutMux_Alt5 = 9, /*!< Output Mux 5. */ + COMP_OutMux_Alt6 = 10, /*!< Output Mux 6. */ + COMP_OutMux_Alt7 = 11, /*!< Output Mux 7. */ +} COMP_OutMux_Type; + +/*! + * @brief COMP input Mux type. + */ +typedef enum +{ + COMP_InMux_Alt0 = 0, /*!< Input Mux 0. */ + COMP_InMux_Alt1 = 1, /*!< Input Mux 1. */ + COMP_InMux_Alt2 = 2, /*!< Input Mux 2. */ + COMP_InMux_Alt3 = 3, /*!< Input Mux 3. */ + COMP_InMux_Alt4 = 4, /*!< Input Mux 4. */ +} COMP_InMux_Type; + +/*! + * @brief COMP speed type. + */ +typedef enum +{ + COMP_Speed_High = 0, /*!< High speed, high power. */ + COMP_Speed_Middle = 1, /*!< Middle speed, middle power. */ + COMP_Speed_Low = 2, /*!< Low speed, low power. */ + COMP_Speed_DeepLow = 3, /*!< Deep low speed, deep low power. */ +} COMP_Speed_Type; + +/*! + * @brief COMP external reference voltage source type. + */ +typedef enum +{ + COMP_ExtVrefSource_VREFINT = 0, /*!< Internal reference voltage. */ + COMP_ExtVrefSource_VDDA = 1, /*!< VDDA voltage. */ +} COMP_ExtVrefSource_Type; + +/*! + * @brief COMP external reference voltage type. + */ +typedef enum +{ + COMP_ExtVrefVolt_Alt0 = 0, /*!< External reference voltage Alt 0. */ + COMP_ExtVrefVolt_Alt1 = 1, /*!< External reference voltage Alt 1. */ + COMP_ExtVrefVolt_Alt2 = 2, /*!< External reference voltage Alt 2. */ + COMP_ExtVrefVolt_Alt3 = 3, /*!< External reference voltage Alt 3. */ + COMP_ExtVrefVolt_Alt4 = 4, /*!< External reference voltage Alt 4. */ + COMP_ExtVrefVolt_Alt5 = 5, /*!< External reference voltage Alt 5. */ + COMP_ExtVrefVolt_Alt6 = 6, /*!< External reference voltage Alt 6. */ + COMP_ExtVrefVolt_Alt7 = 7, /*!< External reference voltage Alt 7. */ + COMP_ExtVrefVolt_Alt8 = 8, /*!< External reference voltage Alt 8. */ + COMP_ExtVrefVolt_Alt9 = 9, /*!< External reference voltage Alt 9. */ + COMP_ExtVrefVolt_Alt10 = 10, /*!< External reference voltage Alt 10. */ + COMP_ExtVrefVolt_Alt11 = 11, /*!< External reference voltage Alt 11. */ + COMP_ExtVrefVolt_Alt12 = 12, /*!< External reference voltage Alt 12. */ + COMP_ExtVrefVolt_Alt13 = 13, /*!< External reference voltage Alt 13. */ + COMP_ExtVrefVolt_Alt14 = 14, /*!< External reference voltage Alt 14. */ + COMP_ExtVrefVolt_Alt15 = 15, /*!< External reference voltage Alt 15. */ +} COMP_ExtVrefVolt_Type; + +/*! + * @brief COMP round robin period type. + * + * wait n APB clock to compare next channel. + */ +typedef enum +{ + COMP_RoundRobinPeriod_1 = 0, /*!< Wait 1 PCLK2 to compare next channel. */ + COMP_RoundRobinPeriod_2 = 1, /*!< Wait 2 PCLK2 to compare next channel. */ + COMP_RoundRobinPeriod_4 = 2, /*!< Wait 4 PCLK2 to compare next channel. */ + COMP_RoundRobinPeriod_8 = 3, /*!< Wait 8 PCLK2 to compare next channel. */ + COMP_RoundRobinPeriod_16 = 4, /*!< Wait 16 PCLK2 to compare next channel. */ + COMP_RoundRobinPeriod_32 = 5, /*!< Wait 32 PCLK2 to compare next channel. */ + COMP_RoundRobinPeriod_64 = 6, /*!< Wait 64 PCLK2 to compare next channel. */ + COMP_RoundRobinPeriod_128 = 7, /*!< Wait 128 PCLK2 to compare next channel. */ +} COMP_RoundRobinPeriod_Type; + +/*! + * @brief COMP round robin channel Type. + */ +typedef enum +{ + COMP_RoundRobinChnGroup_Alt0 = 0, /*!< Compare the positive input 1 & 2. */ + COMP_RoundRobinChnGroup_Alt1 = 1, /*!< Compare the positive input 1, 2 & 3. */ +} COMP_RoundRobinChnGroup_Type; + +/*! + * @brief This type of structure instance is used to keep the settings when calling the @ref COMP_Init() to initialize the COMP module. + */ +typedef struct +{ + COMP_OutFilter_Type OutFilter; /*!< Specify the output filter. */ + COMP_Hysteresis_Type Hysteresis; /*!< Specify the hysteresis. */ + bool OutInvert; /*!< Specify the output invert. */ + COMP_OutMux_Type OutMux; /*!< Specify the output. */ + COMP_InMux_Type PosInMux; /*!< Specify the positive input. */ + COMP_InMux_Type InvInMux; /*!< Specify the nagetive input. */ + COMP_Speed_Type Speed; /*!< Specify the compare speed. */ +} COMP_Init_Type; + +/*! + * @brief This type of structure instance is used to keep the settings when calling the @ref COMP_EnableExtVrefConf() to enable the COMP ext vref. + */ +typedef struct +{ + COMP_ExtVrefSource_Type VrefSource; /*!< Specify the Vref source. */ + COMP_ExtVrefVolt_Type Volt; /*!< Specify the Vref voltage. */ +} COMP_ExtVrefConf_Type; + +/*! + * @brief This type of structure instance is used to keep the settings when calling the @ref COMP_EnableRoundRobinConf() to enable the COMP round robin. + */ +typedef struct +{ + COMP_RoundRobinPeriod_Type Period; /*!< Specify the round robin period. */ + bool InvInFix; /*!< Specify the nagetive input fix. */ + COMP_RoundRobinChnGroup_Type ChnGroup; /*!< Specify the round robin channel. */ +} COMP_RoundRobinConf_Type; + +/*! + * @brief Initialize the COMP module. + * + * @param COMPx COMP instance. + * @param channel COMP channel. + * @param init Pointer to the initialization structure. See to @ref COMP_Init_Type. + * @return None. + */ +void COMP_Init(COMP_Type * COMPx, uint32_t channel, COMP_Init_Type * init); + +/*! + * @brief Enable the COMP module. + * + * @param COMPx COMP instance. + * @param channel COMP channel. + * @param enable 'true' to enable the module, 'false' to disable the module. + * @return None. + */ +void COMP_Enable(COMP_Type * COMPx, uint32_t channel, bool enable); + +/*! + * @brief Keep the COMP settings not changed. + * + * @param COMPx COMP instance. + * @param channel COMP channel. + * @return None. + */ +void COMP_Lock(COMP_Type * COMPx, uint32_t channel); + +/*! + * @brief Get comp output status. + * + * @param COMPx COMP instance. + * @param channel COMP channel. + * @return output status. + */ +bool COMP_GetOutputStatus(COMP_Type * COMPx, uint32_t channel); + +/*! + * @brief Enable the COMP ext Vref. + * + * @param COMPx COMP instance. + * @param init Pointer to the initialization structure. See to @ref COMP_ExtVrefConf_Type, if null, disable ext Vref. + * @return None. + */ +void COMP_EnableExtVrefConf(COMP_Type * COMPx, COMP_ExtVrefConf_Type * conf); + +/*! + * @brief Enable polling function. + * + * Enable round robin function, the comp channel can get positive input 1, 2 & 3 status. + * + * @param COMPx COMP instance. + * @param channel COMP channel. + * @param init Pointer to the initialization structure. See to @ref COMP_RoundRobinConf_Type, if null, disable round robin. + * @return None. + */ +void COMP_EnableRoundRobinConf(COMP_Type * COMPx, uint32_t channel, COMP_RoundRobinConf_Type * conf); + +/*! + * @brief Get round robin output status. + * + * @param COMPx COMP instance. + * @param channel COMP channel. + * @param pos_in Positive input Mux. + * @return Status of comp channel output level. + */ +bool COMP_GetRoundRobinOutStatus(COMP_Type * COMPx, uint32_t channel, COMP_InMux_Type pos_in); + +/*! + *@} + */ + +#endif /* __HAL_COMP_H__ */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dac.h b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dac.h new file mode 100644 index 0000000000..5e6498468e --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dac.h @@ -0,0 +1,364 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef __HAL_DAC_H__ +#define __HAL_DAC_H__ + +#include "hal_common.h" + +/*! + * @addtogroup DAC + * @{ + */ + +/*! + * @brief DAC driver version number. + */ +#define DAC_DRIVER_VERSION 0u /*!< dac_0. */ + +/*! + * @addtogroup DAC_CHANNEL_SELECTION + * @{ + */ +#define DAC_CHN_NUM (2u) /*!< The total number of DAC channel. */ +#define DAC_CHN_1 (0u) /*!< The selection of DAC Channel 1. */ +#define DAC_CHN_2 (1u) /*!< The selection of DAC Channel 2. */ +/*! + *@} + */ + +/*! + * @brief DAC align type. + */ +typedef enum +{ + DAC_Align_8b_Dual = 0u, /*!< The selection of dual channel data alignment of 8b right. */ + DAC_Align_8b_Right = 1u, /*!< The selection of single channel data alignment of 8b right. */ + DAC_Align_12b_Left = 2u, /*!< The selection of single channel data alignment of 12b left. */ + DAC_Align_12b_Right = 3u, /*!< The selection of single channel data alignment of 12b right. */ + DAC_Align_12b_Dual_Left = 4u, /*!< The selection of dual channel data alignment of 12b left. */ + DAC_Align_12b_Dual_Right = 5u, /*!< The selection of dual channel data alignment of 12b right. */ +} DAC_Align_Type; + +/*! + * @brief DAC trigger source selection. + */ +typedef enum +{ + DAC_TrgSource_Alt0 = 0u, /*!< The selection of the documented trigger of value 0. */ + DAC_TrgSource_Alt1 = 1u, /*!< The selection of the documented trigger of value 1. */ + DAC_TrgSource_Alt2 = 2u, /*!< The selection of the documented trigger of value 2. */ + DAC_TrgSource_Alt3 = 3u, /*!< The selection of the documented trigger of value 3. */ + DAC_TrgSource_Alt4 = 4u, /*!< The selection of the documented trigger of value 4. */ + DAC_TrgSource_Alt5 = 5u, /*!< The selection of the documented trigger of value 5. */ + DAC_TrgSource_Alt6 = 6u, /*!< The selection of the documented trigger of value 6. */ + DAC_TrgSource_Alt7 = 7u, /*!< The selection of the documented software trigger. */ + DAC_TrgSource_None = 16u, /*!< No trigger to be used. */ +} DAC_TrgSource_Type; + +/*! + * @brief DAC LFSR unmask bit selector type for adding noise wave. + */ +typedef enum +{ + DAC_AddNoise_LFSRUnMask_0 = 0u, /*!< Unmask DAC channel LFSR bit0. */ + DAC_AddNoise_LFSRUnMask_1 = 1u, /*!< Unmask DAC channel LFSR bit[1:0]. */ + DAC_AddNoise_LFSRUnMask_2 = 2u, /*!< Unmask DAC channel LFSR bit[2:0]. */ + DAC_AddNoise_LFSRUnMask_3 = 3u, /*!< Unmask DAC channel LFSR bit[3:0]. */ + DAC_AddNoise_LFSRUnMask_4 = 4u, /*!< Unmask DAC channel LFSR bit[4:0]. */ + DAC_AddNoise_LFSRUnMask_5 = 5u, /*!< Unmask DAC channel LFSR bit[5:0]. */ + DAC_AddNoise_LFSRUnMask_6 = 6u, /*!< Unmask DAC channel LFSR bit[6:0]. */ + DAC_AddNoise_LFSRUnMask_7 = 7u, /*!< Unmask DAC channel LFSR bit[7:0]. */ + DAC_AddNoise_LFSRUnMask_8 = 8u, /*!< Unmask DAC channel LFSR bit[8:0]. */ + DAC_AddNoise_LFSRUnMask_9 = 9u, /*!< Unmask DAC channel LFSR bit[9:0]. */ + DAC_AddNoise_LFSRUnMask_10 = 10u, /*!< Unmask DAC channel LFSR bit[10:0]. */ + DAC_AddNoise_LFSRUnMask_11 = 11u, /*!< Unmask DAC channel LFSR bit[11:0]. */ +} DAC_AddNoise_Type; + +/*! + * @brief DAC triangle amplitude selector type for adding triangle wave. + */ +typedef enum +{ + DAC_AddTriangle_LFSRAmplitude_1 = 0u, /*!< Max triangle amplitude of 1. */ + DAC_AddTriangle_LFSRAmplitude_3 = 1u, /*!< Max triangle amplitude of 3. */ + DAC_AddTriangle_LFSRAmplitude_7 = 2u, /*!< Max triangle amplitude of 7. */ + DAC_AddTriangle_LFSRAmplitude_15 = 3u, /*!< Max triangle amplitude of 15. */ + DAC_AddTriangle_LFSRAmplitude_31 = 4u, /*!< Max triangle amplitude of 31. */ + DAC_AddTriangle_LFSRAmplitude_63 = 5u, /*!< Max triangle amplitude of 63. */ + DAC_AddTriangle_LFSRAmplitude_127 = 6u, /*!< Max triangle amplitude of 127. */ + DAC_AddTriangle_LFSRAmplitude_255 = 7u, /*!< Max triangle amplitude of 255. */ + DAC_AddTriangle_LFSRAmplitude_511 = 8u, /*!< Max triangle amplitude of 511. */ + DAC_AddTriangle_LFSRAmplitude_1023 = 9u, /*!< Max triangle amplitude of 1023. */ + DAC_AddTriangle_LFSRAmplitude_2047 = 10u, /*!< Max triangle amplitude of 2047. */ + DAC_AddTriangle_LFSRAmplitude_4095 = 11u, /*!< Max triangle amplitude of 4095. */ +} DAC_AddTriangle_Type; + +/*! + * @brief This type of structure instance is used to keep the settings when calling the @ref DAC_EnableAddNoise() to initialize the DAC noise wave generation. + */ +typedef struct +{ + DAC_AddNoise_Type AddNoise; /*!< Specify the noise wave pattern. */ +} DAC_AddNoise_Init_Type; + +/*! + * @brief This type of structure instance is used to keep the settings when calling the @ref DAC_EnableAddTriangle() to initialize the DAC triangle wave generation. + */ +typedef struct +{ + DAC_AddTriangle_Type AddTriangle; /*!< Specify the triangle wave pattern. */ +} DAC_AddTriangle_Init_Type; + +/*! + * @brief This type of structure instance is used to keep the settings when calling the @ref DAC_Init() to initialize the DAC module. + */ +typedef struct +{ + DAC_TrgSource_Type TrgSource; /*!< Specify whether to use the trigger and the trigger type. */ + bool EnableOutBuf; /*!< Specify whether output buffer is enabled. */ +} DAC_Init_Type; + +/*! + * @brief Initialize the DAC module. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param init Pointer to the initialization structure. See to @ref DAC_Init_Type. + * @return None. + */ +void DAC_Init(DAC_Type * DACx, uint32_t channel, DAC_Init_Type * init); + +/*! + * @brief Enable the DAC module. + * + * The DAC module should be enabled before outputting voltage. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param enable 'true' to enable the module, 'false' to disable the module. + * @return None. + */ +void DAC_Enable(DAC_Type * DACx, uint32_t channel, bool enable); + +/*! + * @brief Get the echo data from the output of the indicated DAC channel. + * + * The value in DAC_DORx register takes effect on the actual output of DAC. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @return The indicated DAC channel data output value. + */ +uint32_t DAC_GetData(DAC_Type * DACx, uint32_t channel); + +/*! + * @brief Put the value into the indicated channel of the DAC module with the alignment. + * + * The value in DAC_DORx register takes effect on the actual output of DAC. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param value Data value to be put in indicated DAC channel for conversion. + * @param align Alignment the value expected to be put into the conversion. See to @ref DAC_Align_Type. + * @return The current converted value of the indicated DAC channel. + */ +uint32_t DAC_PutData(DAC_Type * DACx, uint32_t channel, uint32_t value, DAC_Align_Type align); + +/*! + * @brief Enable the feature of generating noise wave from the DAC module. + * + * If enable additional noise wave, the output value will depend on the the unmask LFSR bit and input of the indicated channel. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param init Pointer to the initialization structure. See to @ref DAC_AddNoise_Init_Type. If null, disable the wave generation. + * @return None. + */ +void DAC_EnableAddNoise(DAC_Type * DACx, uint32_t channel, DAC_AddNoise_Init_Type * init); + +/*! + * @brief Enable the feature of generating triangle wave from the DAC module. + * + * Defaultedly, DAC does not generate any wave. + * If enable additional triangle wave, the output value will depend on the the indicated amplitude and input of the indicated channel. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param init Pointer to the initialization structure. See to @ref DAC_AddTriangle_Init_Type. If null, disable the wave generation. + * @return None. + */ +void DAC_EnableAddTriangle(DAC_Type * DACx, uint32_t channel, DAC_AddTriangle_Init_Type * init); + +/*! + * @brief Enable the DMA trigger from the DAC module. + * + * The DMA trigger events are the same as the intertupts. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param enable 'true' to enable the DMA trigger, 'false' to disable the DMA trigger. + * @return None. + */ +void DAC_EnableDMA(DAC_Type * DACx, uint32_t channel, bool enable); + +/*! + * @brief Do trigger the indicated DAC channel with software trigger. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @return None. + */ +void DAC_DoSwTrigger(DAC_Type * DACx, uint32_t channel); + +/*! + * @brief Do trigger the dual DAC channels with software trigger simultaneously. + * + * @param DACx DAC instance. + * @return None. + */ +void DAC_DoDualChannelSwTrigger(DAC_Type * DACx); + +/*! + * @brief Get the indicated register address of the DAC module. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param align Alignment that the data expects to br transferred. See to @ref DAC_Align_Type. + * @return The value of the address for indicated align type of the DAC channel. + */ +uint32_t DAC_GetDataRegAddr(DAC_Type * DACx, uint32_t channel, DAC_Align_Type align); + +/*! + * @brief Put 8-bit value into the indicated channel of the DAC module. + * + * The low 8-bit of the setting value here will be output with 4-bit left shift. + * If the value is 0x1f, the output will be 0x1f0. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param value Data value to be put in indicated DAC channel for conversion. + * @return None. + */ +void DAC_PutData8bRightAlign(DAC_Type * DACx, uint32_t channel, uint32_t value); + +/*! + * @brief Put the 12-bit value into indicated channel of the DAC module. + * + * The low 12-bit of the setting value here will be output after 4-bit right shift. + * If the value is 0x1ff, the output will be 0x1f. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param value Data value to be put in indicated DAC channel for conversion. + * @return None. + */ +void DAC_PutData12bLeftAlign(DAC_Type * DACx, uint32_t channel, uint32_t value); + +/*! + * @brief Put the current data into indicated channel of the DAC module. + * + * The low 12-bit of the setting value here will output with the original value. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @param value Data value to be put in indicated DAC channel for conversion. + * @return None. + */ +void DAC_PutData12bRightAlign(DAC_Type * DACx, uint32_t channel, uint32_t value); + +/*! + * @brief Respectively put the value into the dual channels of the DAC module 8b right aligned. + * + * Simultaneously output the low 8-bit of the low 16-bit and high 16-bit of the 32-bit value seperately with a 4-bit left shift. + * If value is 0x011f01ff, the output of each channel will be 0xff0 ( channel 1 ) and 0x1f0 ( channel 2 ). + * + * @param DACx DAC instance. + * @param value Data value to be put in DAC channel 1 and DAC channel 2 for conversion. + * @return None. + */ +void DAC_PutDualChannelData8bRightAlign(DAC_Type * DACx, uint32_t value); + +/*! + * @brief Put the data into the dual channel of the DAC module 12b left aligned. + * + * Simultaneously output the high 12-bit of the low 16-bit and high 16-bit of the 32-bit value seperately after 4-bit right shift. + * If value is 0x011f01ff, the output of each channel will be 0x01f ( channel 1 ) and 0x011 ( channel 2 ). + * + * @param DACx DAC instance. + * @param value Data value to be put in DAC channel 1 and DAC channel 2 for conversion. + * @return None. + */ +void DAC_PutDualChannelData12bLeftAlign(DAC_Type * DACx, uint32_t value); + +/*! + * @brief Put the data into the dual channel of the DAC module 12b right aligned. + * + * Simultaneously output the low 12-bit of the low 16-bit and high 16-bit of the 32-bit value seperately. + * + * @param DACx DAC instance. + * @param value Data value to be put in DAC channel 1 and DAC channel 2 for conversion. + * @return None. + */ +void DAC_PutDualChannelData12bRightAlign(DAC_Type * DACx, uint32_t value); + +/*! + * @brief Get the 8-bit data register address of the DAC module. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @return The value of the address for DAC module's 8-bit data register . + */ +uint32_t DAC_GetData8bRegAddr(DAC_Type * DACx, uint32_t channel); + +/*! + * @brief Get the 12-bit left-aligned data register address of the DAC module. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @return The value of the address for DAC module's 12-bit left-aligned data register . + */ +uint32_t DAC_GetData12bLeftRegAddr(DAC_Type * DACx, uint32_t channel); + +/*! + * @brief Get the 12-bit right-aligned data register address of the DAC module. + * + * @param DACx DAC instance. + * @param channel Indicated DAC channel. See to @ref DAC_CHANNEL_SELECTION. + * @return The value of the address for DAC module's 12-bit right-aligned data register . + */ +uint32_t DAC_GetData12bRightRegAddr(DAC_Type * DACx, uint32_t channel); + +/*! + * @brief Get the dual channel 8-bit data register address of the DAC module. + * + * @param DACx DAC instance. + * @return The value of the address for DAC module's dual channel 8-bit data register . + */ +uint32_t DAC_GetDualChannelData8bRegAddr(DAC_Type * DACx); + +/*! + * @brief Get the dual channel 12-bit left-aligned data register address of the DAC module. + * + * @param DACx DAC instance. + * @return The value of the address for DAC module's 12-bit dual channel left-aligned data register . + */ +uint32_t DAC_GetDualChannelData12bLeftRegAddr(DAC_Type * DACx); + +/*! + * @brief Get the dual channel 12-bit right-aligned data register address of the DAC module. + * + * @param DACx DAC instance. + * @return The value of the address for DAC module's 12-bit dual channel right-aligned data register . + */ +uint32_t DAC_GetDualChannelData12bRightRegAddr(DAC_Type * DACx); + +/*! + *@} + */ + +#endif /* __HAL_DAC_H__ */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma.h b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma.h new file mode 100644 index 0000000000..4a834e125c --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma.h @@ -0,0 +1,153 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef __HAL_DMA_H__ +#define __HAL_DMA_H__ + +#include "hal_common.h" + +/*! + * @addtogroup DMA + * @{ + */ + +/*! + * @addtogroup DMA_CHANNEL_INT + * @{ + */ +#define DMA_CHN_INT_XFER_GLOBAL (0x1u << 0u) /*!< DMA global interrupt channel. */ +#define DMA_CHN_INT_XFER_DONE (0x1u << 1u) /*!< DMA end of transfer interrupt channel. */ +#define DMA_CHN_INT_XFER_HALF_DONE (0x1u << 2u) /*!< DMA half transfer interrupt channel. */ +#define DMA_CHN_INT_XFER_ERR (0x1u << 3u) /*!< DMA transfer error interrupt channel. */ +/*! + * @} + */ + + +/*! + * @brief Define the enum type of DMA_XferMode_Type. + */ +typedef enum +{ + DMA_XferMode_PeriphToMemory = 0u, /*!< memory to memory mode, from periph addr to memory addr. */ + DMA_XferMode_MemoryToPeriph = 1u, /*!< memory to memory mode, from periph addr to memory addr. */ + DMA_XferMode_PeriphToMemoryBurst = 2u, /*!< memory to memory mode, from periph addr to memory addr. */ + DMA_XferMode_MemoryToPeriphBurst = 3u, /*!< memory to memory mode, from memory addr to periph addr. */ +} DMA_XferMode_Type; + +/*! + * @brief Define the enum type of DMA_ReloadMode_Type. + */ +typedef enum +{ + DMA_ReloadMode_OneTime = 0u, /*!< the count is exhausted after the xfer is done. */ + DMA_ReloadMode_AutoReload = 1u, /*!< auto reload the count for the new xfer. */ + DMA_ReloadMode_AutoReloadContinuous = 2u, /*!< auto reload the count for the next xfer, and always run. */ +} DMA_ReloadMode_Type; + +/*! + * @brief Incremental mode of peripherals and memories. + */ +typedef enum +{ + DMA_AddrIncMode_StayAfterXfer = 0u, /*!< Peripheral access address accumulation. */ + DMA_AddrIncMode_IncAfterXfer = 1u, /*!< Memory access address accumulation. */ +} DMA_AddrIncMode_Type; + +/*! + * @brief Define the enum type of DMA xfer width type. + */ +typedef enum +{ + DMA_XferWidth_8b = 0u, /*!< Xfer width 8 bits. */ + DMA_XferWidth_16b = 1u, /*!< Xfer width 16 bits. */ + DMA_XferWidth_32b = 2u, /*!< Xfer width 32 bits. */ +} DMA_XferWidth_Type; + +/*! + * @brief Configure DMA Priority. + */ +typedef enum +{ + DMA_Priority_Low = 0u, /*!< Low Priority. */ + DMA_Priority_Middle = 1u, /*!< Middle Priority. */ + DMA_Priority_High = 2u, /*!< High Priority. */ + DMA_Priority_Highest = 3u, /*!< Highest Priority. */ +} DMA_Priority_Type; + +/*! + * @brief This type of structure instance is used to keep the settings when calling the @ref DMA_InitChannel() to initialize the DMA module. + */ +typedef struct +{ + DMA_XferMode_Type XferMode; /*!< Specify whether the Receive or Transmit mode is enabled or not. */ + DMA_ReloadMode_Type ReloadMode; /*!< Specify whether to automatically reload the next transfer count when the count is exhausted. */ + DMA_AddrIncMode_Type PeriphAddrIncMode; /*!< Specify peripheral Address Inc Mode. */ + DMA_AddrIncMode_Type MemAddrIncMode; /*!< Specify Memory Address Inc Mode. */ + DMA_XferWidth_Type XferWidth; /*!< Specify the transmission data width. */ + DMA_Priority_Type Priority; /*!< Specify priority mode. */ + uint32_t XferCount; /*!< Specify CircularMode's count. */ + uint32_t MemAddr; /*!< Specify Memory Address. */ + uint32_t PeriphAddr; /*!< Specify Periph Address. */ +} DMA_Channel_Init_Type; + +/*! + * @brief Initialize the DMA module. + * + * @param DMAx DMA instance. + * @param channel Channel corresponding to DMA controller. + * @param init Pointer to the initialization structure. See to @ref DMA_Channel_Init_Type. + * @return None. + */ +uint32_t DMA_InitChannel(DMA_Type * DMAx, uint32_t channel, DMA_Channel_Init_Type * init); + +/*! + * @brief enable the DMA channel interrupts of the DMA module. + * + * @param DMAx DMA instance. + * @param channel Channel corresponding to DMA controller. + * @param interrupts Interrupt code masks. See to @ref DMA_CHANNEL_INT. + * @param enable 'true' to enable the DMA channel interrupts, 'false' to disable the DMA channel interrupts. + * @return None. + */ +void DMA_EnableChannelInterrupts(DMA_Type * DMAx, uint32_t channel, uint32_t interrupts, bool enable); + +/*! + * @brief Get the channel interrupts status flags of the DMA module. + * + * @param DMAx DMA instance. + * @param channel Channel corresponding to DMA controller in DMA. See to @ref DMA_CHANNEL_INT. + * @return Interrupt status flags. + */ +uint32_t DMA_GetChannelInterruptStatus(DMA_Type * DMAx, uint32_t channel); + +/*! + * @brief Clear the channel interrupts status flags of the DMA module. + * + * @param DMAx DMA instance. + * @param channel Channel corresponding to DMA controller. See to @ref DMA_CHANNEL_INT. + * @param interrupts Interrupt code masks. + * @return None. + */ +void DMA_ClearChannelInterruptStatus(DMA_Type * DMAx, uint32_t channel, uint32_t interrupts); + +/*! + * @brief Enable the channel of the DMA module. + * + * @param DMAx DMA instance. + * @param channel Channel corresponding to DMA controller. See to @ref DMA_CHANNEL_INT. + * @param enable 'true' to enable the DMA controller sends a reply signal to the peripheral, 'false' to disable the DMA controller sends a reply signal to the peripheral. + * @return None. + */ +void DMA_EnableChannel(DMA_Type * DMAx, uint32_t channel, bool enable); + +/*! + *@} + */ + +#endif /* __HAL_DMA_H__ */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma_request.h b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma_request.h new file mode 100644 index 0000000000..dc771b4194 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_dma_request.h @@ -0,0 +1,187 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#ifndef __HAL_DMA_REQUESET_H__ +#define __HAL_DMA_REQUESET_H__ + +#if 0 + +#define DMA_REQ_GET_DMA_INSTANCE(code) (uint32_t)((code) >> 8u) +#define DMA_REQ_GET_DMA_CHANNEL(code) (uint32_t)((code) & 0xFF) +#define DMA_REQ_DMA_INSTANCE(dmax) (uint32_t)((dmax) << 8u) +#define DMA_REQ_DMA_CHANNEL(channel) (uint32_t)((channel) & 0xFF) + + +#define DMA_REQ_DMA1_ADC1 0u +#define DMA_REQ_DMA1_UART6_RX 0u +#define DMA_REQ_DMA1_TIM2_CC3 0u +#define DMA_REQ_DMA1_TIM4_CC1 0u +#define DMA_REQ_DMA1_ADC2 1u +#define DMA_REQ_DMA1_SPI1_RX 1u +#define DMA_REQ_DMA1_UART3_TX 1u +#define DMA_REQ_DMA1_TIM1_CC1 1u +#define DMA_REQ_DMA1_TIM2_UP 1u +#define DMA_REQ_DMA1_TIM3_CC3 1u +#define DMA_REQ_DMA1_SPI1_TX 2u +#define DMA_REQ_DMA1_UART3_RX 2u +#define DMA_REQ_DMA1_TIM1_CC2 2u +#define DMA_REQ_DMA1_TIM3_CC4 2u +#define DMA_REQ_DMA1_TIM2_UP 2u +#define DMA_REQ_DMA1_SPI2_RX 3u +#define DMA_REQ_DMA1_UART1_TX 3u +#define DMA_REQ_DMA1_I2C2_TX 3u +#define DMA_REQ_DMA1_TIM1_CC4 3u +#define DMA_REQ_DMA1_TIM1_TRIG 3u +#define DMA_REQ_DMA1_TIM1_COM 3u +#define DMA_REQ_DMA1_TIM4_CC2 3u +#define DMA_REQ_DMA1_SPI2_TX 4u +#define DMA_REQ_DMA1_UART1_RX 4u +#define DMA_REQ_DMA1_I2C2_RX 4u +#define DMA_REQ_DMA1_TIM1_UP 4u +#define DMA_REQ_DMA1_TIM2_CC1 4u +#define DMA_REQ_DMA1_TIM4_CC3 4u +#define DMA_REQ_DMA1_UART2_RX 5u +#define DMA_REQ_DMA1_I2C1_TX 5u +#define DMA_REQ_DMA1_TIM1_CC3 5u +#define DMA_REQ_DMA1_TIM3_CC1 5u +#define DMA_REQ_DMA1_TIM3_TRIG 5u +#define DMA_REQ_DMA1_UART2_TX 6u +#define DMA_REQ_DMA1_I2C1_RX 6u +#define DMA_REQ_DMA1_TIM2_CC2 6u +#define DMA_REQ_DMA1_TIM2_CC4 6u +#define DMA_REQ_DMA1_TIM4_UP 6u + +#define DMA_REQ_DMA2_SPI3_RX 0u +#define DMA_REQ_DMA2_UART5_RX 0u +#define DMA_REQ_DMA2_UART7_RX 0u +#define DMA_REQ_DMA2_TIM5_CC4 0u +#define DMA_REQ_DMA2_TIM5_TRIG 0u +#define DMA_REQ_DMA2_TIM8_CC3 0u +#define DMA_REQ_DMA2_TIM8_UP 0u +#define DMA_REQ_DMA2_SPI3_TX 1u +#define DMA_REQ_DMA2_UART5_TX 1u +#define DMA_REQ_DMA2_UART7_TX 1u +#define DMA_REQ_DMA2_TIM5_CC3 1u +#define DMA_REQ_DMA2_TIM5_UP 1u +#define DMA_REQ_DMA2_TIM8_CC4 1u +#define DMA_REQ_DMA2_TIM8_TRIG 1u +#define DMA_REQ_DMA2_TIM8_COM 1u +#define DMA_REQ_DMA2_UART4_RX 2u +#define DMA_REQ_DMA2_UART8_RX 2u +#define DMA_REQ_DMA2_TIM6_UP 2u +#define DMA_REQ_DMA2_DAC_CH1 2u +#define DMA_REQ_DMA2_TIM8_CC1 2u +#define DMA_REQ_DMA2_UART6_TX 3u +#define DMA_REQ_DMA2_SDIO 3u +#define DMA_REQ_DMA2_TIM5_CC2 3u +#define DMA_REQ_DMA2_TIM6_UP 3u +#define DMA_REQ_DMA2_DAC_CH2 3u +#define DMA_REQ_DMA2_ADC3 4u +#define DMA_REQ_DMA2_UART4_TX 4u +#define DMA_REQ_DMA2_UART8_TX 4u +#define DMA_REQ_DMA2_TIM5_CC1 4u +#define DMA_REQ_DMA2_TIM8_CC2 4u +#endif + +/* ADC. */ +#define DMA_REQ_DMA1_ADC1 0u +#define DMA_REQ_DMA1_ADC2 1u +#define DMA_REQ_DMA2_ADC3 4u + +/* DAC. */ +#define DMA_REQ_DMA2_DAC_CH1 2u +#define DMA_REQ_DMA2_DAC_CH2 3u + +/* UART. */ +#define DMA_REQ_DMA1_UART1_TX 3u +#define DMA_REQ_DMA1_UART1_RX 4u +#define DMA_REQ_DMA1_UART2_RX 5u +#define DMA_REQ_DMA1_UART2_TX 6u +#define DMA_REQ_DMA1_UART3_RX 2u +#define DMA_REQ_DMA1_UART3_TX 1u +#define DMA_REQ_DMA2_UART4_RX 2u +#define DMA_REQ_DMA2_UART4_TX 4u +#define DMA_REQ_DMA2_UART5_RX 0u +#define DMA_REQ_DMA2_UART5_TX 1u +#define DMA_REQ_DMA1_UART6_RX 0u +#define DMA_REQ_DMA2_UART6_TX 3u +#define DMA_REQ_DMA2_UART7_RX 0u +#define DMA_REQ_DMA2_UART7_TX 1u +#define DMA_REQ_DMA2_UART8_RX 2u +#define DMA_REQ_DMA2_UART8_TX 4u + +/* SPI. */ +#define DMA_REQ_DMA1_SPI1_RX 1u +#define DMA_REQ_DMA1_SPI1_TX 2u +#define DMA_REQ_DMA1_SPI2_RX 3u +#define DMA_REQ_DMA1_SPI2_TX 4u +#define DMA_REQ_DMA2_SPI3_RX 0u +#define DMA_REQ_DMA2_SPI3_TX 1u + +/* I2C. */ +#define DMA_REQ_DMA1_I2C1_RX 6u +#define DMA_REQ_DMA1_I2C1_TX 5u +#define DMA_REQ_DMA1_I2C2_RX 4u +#define DMA_REQ_DMA1_I2C2_TX 3u + +/* TIM1. */ +#define DMA_REQ_DMA1_TIM1_CC1 1u +#define DMA_REQ_DMA1_TIM1_CC2 2u +#define DMA_REQ_DMA1_TIM1_CC3 5u +#define DMA_REQ_DMA1_TIM1_CC4 3u +#define DMA_REQ_DMA1_TIM1_TRIG 3u +#define DMA_REQ_DMA1_TIM1_COM 3u +#define DMA_REQ_DMA1_TIM1_UP 4u + +/* TIM2. */ +#define DMA_REQ_DMA1_TIM2_CC1 4u +#define DMA_REQ_DMA1_TIM2_CC2 6u +#define DMA_REQ_DMA1_TIM2_CC3 0u +#define DMA_REQ_DMA1_TIM2_CC4 6u +#define DMA_REQ_DMA1_TIM2_UP 1u + +/* TIM3. */ +#define DMA_REQ_DMA1_TIM3_CC1 5u +#define DMA_REQ_DMA1_TIM3_CC3 1u +#define DMA_REQ_DMA1_TIM3_CC4 2u +#define DMA_REQ_DMA1_TIM3_UP 2u +#define DMA_REQ_DMA1_TIM3_TRIG 5u + +/* TIM4. */ +#define DMA_REQ_DMA1_TIM4_CC1 0u +#define DMA_REQ_DMA1_TIM4_CC2 3u +#define DMA_REQ_DMA1_TIM4_CC3 4u +#define DMA_REQ_DMA1_TIM4_UP 6u + +/* TIM5. */ +#define DMA_REQ_DMA2_TIM5_CC1 4u +#define DMA_REQ_DMA2_TIM5_CC2 3u +#define DMA_REQ_DMA2_TIM5_CC3 1u +#define DMA_REQ_DMA2_TIM5_CC4 0u +#define DMA_REQ_DMA2_TIM5_TRIG 0u +#define DMA_REQ_DMA2_TIM5_UP 1u + +/* TIM6. */ +#define DMA_REQ_DMA2_TIM6_UP 2u + +/* TIM7. */ +#define DMA_REQ_DMA2_TIM7_UP 3u /* DMA_REQ_DMA2_TIM7_UP */ + +/* TIM8. */ +#define DMA_REQ_DMA2_TIM8_CC1 2u +#define DMA_REQ_DMA2_TIM8_CC2 4u +#define DMA_REQ_DMA2_TIM8_CC3 0u +#define DMA_REQ_DMA2_TIM8_CC4 1u +#define DMA_REQ_DMA2_TIM8_UP 0u +#define DMA_REQ_DMA2_TIM8_COM 1u +#define DMA_REQ_DMA2_TIM8_TRIG 1u + +/* SDIO. */ +#define DMA_REQ_DMA2_SDIO 3u + +#endif /* __HAL_DMA_REQUESET_H__ */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_exti.h b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_exti.h new file mode 100644 index 0000000000..95fb4596ab --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Inc/hal_exti.h @@ -0,0 +1,128 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef __HAL_EXTI_H__ +#define __HAL_EXTI_H__ + +#include "hal_common.h" + +/*! + * @addtogroup EXTI + * @{ + */ + +/*! + * @brief EXTI driver version number. + */ +#define EXTI_DRIVER_VERSION 0u /*!< exti_0. */ + +/*! + * @addtogroup EXTI_LINE + * @{ + */ +#define EXTI_LINE_0 (1u << 0u) /*!ADCFG & ~( ADC_ADCFG_ADCPREH_MASK + | ADC_ADCFG_ADCPREL_MASK + | ADC_ADCFG_RSLTCTL_MASK + | ADC_ADCR_ALIGN_MASK ) + ; + /* Prescaler & Resolution. */ + cfg |= ADC_ADCFG_ADCPREL(init->ClockDiv) + | ADC_ADCFG_ADCPREH((init->ClockDiv)>>1) + | ADC_ADCFG_RSLTCTL(init->Resolution) + ; + ADCx->ADCFG = cfg; + /* ADC conversion mode and conversion data result align. */ + ADCx->ADCR = (ADCx->ADCR & ~( ADC_ADCR_ADMD_MASK | ADC_ADCR_ALIGN_MASK) ) + | ADC_ADCR_ADMD(init->ConvMode) + | ADC_ADCR_ALIGN(init->Align) + ; +} + +void ADC_Enable(ADC_Type * ADCx, bool enable) +{ + if (enable) + { + ADCx->ADCFG |= ADC_ADCFG_ADEN_MASK; + } + else + { + ADCx->ADCFG &= ~ADC_ADCFG_ADEN_MASK; + } +} + +void ADC_EnableTempSensor(ADC_Type * ADCx, bool enable) +{ + if (enable) + { + ADCx->ADCFG |= ADC_ADCFG_TSEN_MASK; + } + else + { + ADCx->ADCFG &= ~ADC_ADCFG_TSEN_MASK; + } +} + +/* Use VBG 1.2V as default voltage sensor. */ +void ADC_EnableVoltSensor(ADC_Type * ADCx, bool enable) +{ + if (enable) + { + ADCx ->ADCFG |= ADC_ADCFG_VSEN_MASK; + } + else + { + ADCx->ADCFG &= ~ADC_ADCFG_VSEN_MASK; + } +} + +void ADC_EnableDMA(ADC_Type * ADCx, bool enable) +{ + if (enable) + { + ADCx->ADCR |= ADC_ADCR_DMAEN_MASK; + } + else + { + ADCx->ADCR &= ~ADC_ADCR_DMAEN_MASK; + } +} + +void ADC_EnableInterrupts(ADC_Type * ADCx, uint32_t interrupts, bool enable) +{ + if (enable) + { + if ( 0u != (ADC_STATUS_CONV_SLOT_DONE & interrupts) ) + { + ADCx->ADCR |= ADC_ADCR_EOCIE_MASK; + } + if ( 0u != (ADC_STATUS_CONV_SAMPLE_DONE & interrupts) ) + { + ADCx->ADCR |= ADC_ADCR_EOSMPIE_MASK; + } + if ( 0u != (ADC_STATUS_CONV_SEQ_DONE & interrupts) ) + { + ADCx->ADCR |= ADC_ADCR_ADIE_MASK; + } + if ( 0u != (ADC_STATUS_COMPARE_DONE & interrupts) ) + { + ADCx->ADCR |= ADC_ADCR_ADWIE_MASK; + } + } + else + { + if ( 0u != (ADC_STATUS_CONV_SLOT_DONE & interrupts) ) + { + ADCx->ADCR &= ~ADC_ADCR_EOCIE_MASK; + } + if ( 0u != (ADC_STATUS_CONV_SAMPLE_DONE & interrupts) ) + { + ADCx->ADCR &= ~ADC_ADCR_EOSMPIE_MASK; + } + if ( 0u != (ADC_STATUS_CONV_SEQ_DONE & interrupts) ) + { + ADCx->ADCR &= ~ADC_ADCR_ADIE_MASK; + } + if ( 0u != (ADC_STATUS_COMPARE_DONE & interrupts) ) + { + ADCx->ADCR &= ~ADC_ADCR_ADWIE_MASK; + } + } +} + +uint32_t ADC_GetStatus(ADC_Type * ADCx) +{ + uint32_t flags = 0u; + + if ( 0u != (ADC_ADSTAEXT_EOCIF_MASK & ADCx->ADSTAEXT) ) + { + flags |= ADC_STATUS_CONV_SLOT_DONE; + } + if ( 0u != (ADC_ADSTAEXT_EOSMPIF_MASK & ADCx->ADSTAEXT) ) + { + flags |= ADC_STATUS_CONV_SAMPLE_DONE; + } + if ( 0u != (ADC_ADSTA_ADIF_MASK & ADCx->ADSTA) ) + { + flags |= ADC_STATUS_CONV_SEQ_DONE; + } + if ( 0u != (ADC_ADSTA_ADWIF_MASK & ADCx->ADSTA) ) + { + flags |= ADC_STATUS_COMPARE_DONE; + } + + return flags; +} + +void ADC_ClearStatus(ADC_Type * ADCx, uint32_t flags) +{ + + if ( 0u != (ADC_STATUS_CONV_SLOT_DONE & flags) ) + { + ADCx->ADSTAEXT = ADC_ADSTAEXT_EOCIF_MASK; + } + if ( 0u != (ADC_STATUS_CONV_SAMPLE_DONE & flags) ) + { + ADCx->ADSTAEXT = ADC_ADSTAEXT_EOSMPIF_MASK; + } + if ( 0u != (ADC_STATUS_CONV_SEQ_DONE & flags) ) + { + ADCx->ADSTA = ADC_ADSTA_ADIF_MASK; + } + if ( 0u != (ADC_STATUS_COMPARE_DONE & flags) ) + { + ADCx->ADSTA = ADC_ADSTA_ADWIF_MASK; + } +} + +uint32_t ADC_GetConvResult(ADC_Type * ADCx, uint32_t * channel, uint32_t * flags) +{ + uint32_t tmp32 = ADCx->ADDATA; + + *channel = (tmp32 & ADC_ADDATA_CHANNELSEL_MASK) >> ADC_ADDATA_CHANNELSEL_SHIFT; + if (flags) + { + *flags = (tmp32 & (ADC_ADDATA_OVERRUN_MASK | ADC_ADDATA_VALID_MASK) ) >> ADC_ADDATA_OVERRUN_SHIFT; + } + + return (tmp32 & ADC_ADDATA_DATA_MASK ) >> ADC_ADDATA_DATA_SHIFT; +} + +uint32_t ADC_GetChnConvResult(ADC_Type * ADCx, uint32_t channel, uint32_t * flags) +{ + uint32_t tmp32 = ADCx ->ADDR[channel]; + + if (flags) + { + *flags = (tmp32 & (ADC_ADDR_OVERRUN_MASK | ADC_ADDR_VALID_MASK) ) >> ADC_ADDR_OVERRUN_SHIFT; + } + + return (tmp32 & ADC_ADDR_DATA_MASK ) >> ADC_ADDR_DATA_SHIFT; +} + +void ADC_SetChnSampleTime(ADC_Type * ADCx, uint32_t channel, ADC_SampleTime_Type sample_time) +{ + if (channel < 8u) + { + ADCx->SMPR1 = (ADCx->SMPR1 & ~(0xF << (4u * channel))) | (sample_time << (4u * channel)); + } + else + { + channel-= 8u; + ADCx->SMPR2 = (ADCx->SMPR2 & ~(0xF << (4u * channel))) | (sample_time << (4u * channel)); + } +} + +void ADC_EnableHwTrigger(ADC_Type * ADCx, ADC_HwTrgConf_Type * conf) +{ + if ( !conf ) + { + ADCx->ADCR &= ~ADC_ADCR_TRGEN_MASK; + return; + } + /* Enable the hardware trigger. */ + ADCx->ADCR = ( ADCx->ADCR & ~(ADC_ADCR_TRGSELL_MASK | ADC_ADCR_TRGSELH_MASK | ADC_ADCR_TRGSHIFT_MASK | ADC_ADCR_TRGEDGE_MASK) ) + | ADC_ADCR_TRGEN_MASK + | ADC_ADCR_TRGSELL(conf->Source & 0x7) + | ADC_ADCR_TRGSELH(conf->Source >> 3u) + | ADC_ADCR_TRGSHIFT(conf->DelayCycle) + | ADC_ADCR_TRGEDGE(conf->Edge) + ; +} + +void ADC_EnableRegSeq(ADC_Type * ADCx, ADC_RegSeqConf_Type * conf) +{ + if (!conf) + { + return; + } + + ADCx->ANYCR &= ~ADC_ANYCR_CHANYMDEN_MASK; + + /* enable regular channels. */ + ADCx->ADCHS = conf->SeqSlots; + ADCx->ADCR = (ADCx->ADCR & ~ADC_ADCR_SCANDIR_MASK) + | ADC_ADCR_SCANDIR(conf->SeqDirection) + ; +} + +void ADC_EnableAnySeq(ADC_Type * ADCx, ADC_AnySeqConf_Type * conf) +{ + if (!conf) + { + ADCx->ANYCR &= ~ADC_ANYCR_CHANYMDEN_MASK; + return; + } + + if (conf->SeqLen > 16u) + { + return; /* the available range of seq length is within 16u. */ + } + + /* enable any channel sequence mode. */ + ADCx->ANYCR |= ADC_ANYCR_CHANYMDEN_MASK; + /* select the any slots number. */ + ADCx->ANYCFG = ADC_ANYCFG_CHANYNUM(conf->SeqLen - 1u); + + /* fill the channels into each slot of ANY sequence. */ + uint32_t offset; + for (uint32_t i = 0u; i < conf->SeqLen; i++) + { + if (i < 8u) + { + offset = i; + ADCx->CHANY0 = (ADCx->CHANY0 & ~(0xF << (4u * offset))) | (conf->SeqChannels[i] << (4u * offset)); + } + else if (i < 16) + { + offset = i - 8u; + ADCx->CHANY1 = (ADCx->CHANY1 & ~(0xF << (4u * offset))) | (conf->SeqChannels[i] << (4u * offset)); + } + } +} + +void ADC_DoSwTrigger(ADC_Type * ADCx, bool enable) +{ + if (enable) + { + ADCx->ADCR |= ADC_ADCR_ADST_MASK; + } + else + { + ADCx->ADCR &= ~ADC_ADCR_ADST_MASK; + } +} + +void ADC_EnableHwComp(ADC_Type * ADCx, ADC_HwCompConf_Type * conf) +{ + if ( !conf ) + { + /* disable the hardware compare feature for both regular & any seq. */ + ADCx->ADCFG &= ~ADC_ADCFG_ADWEN_MASK; + return; + } + + /* enable the hardware compare feature. */ + ADCx->ADCFG |= ADC_ADCFG_ADWEN_MASK; + + /* setup the channel in monitor. */ + ADCx->ADCR = (ADCx->ADCR & ~ADC_ADCR_CMPCH_MASK) | ADC_ADCR_CMPCH(conf->ChnNum); + + /* setup the compare boundary. */ + ADCx->ADCMPR = ADC_ADCMPR_CMPLDATA(conf->LowLimit) + | ADC_ADCMPR_CMPHDATA(conf->HighLimit) + ; +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_comp.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_comp.c new file mode 100644 index 0000000000..67eef99747 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_comp.c @@ -0,0 +1,121 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_comp.h" + +void COMP_Init(COMP_Type * COMPx, uint32_t channel, COMP_Init_Type * init) +{ + if ( channel < COMP_CHANNEL_NUM ) + { + COMPx->CSR[channel] = COMP_CSR_OFLT(init->OutFilter) + | COMP_CSR_HYST(init->Hysteresis) + | COMP_CSR_POL(init->OutInvert) + | COMP_CSR_OUTSEL(init->OutMux) + | COMP_CSR_INPSEL(init->PosInMux) + | COMP_CSR_INMSEL(init->InvInMux) + | COMP_CSR_MODE(init->Speed) + ; + } +} + +void COMP_Enable(COMP_Type * COMPx, uint32_t channel, bool enable) +{ + if ( channel < COMP_CHANNEL_NUM ) + { + if ( true == enable ) + { + COMPx->CSR[channel] |= COMP_CSR_EN_MASK; + } + else + { + COMPx->CSR[channel] &= ~COMP_CSR_EN_MASK; + } + } +} + +void COMP_Lock(COMP_Type * COMPx, uint32_t channel) +{ + if ( channel < COMP_CHANNEL_NUM ) + { + COMPx->CSR[channel] |= COMP_CSR_LOCK_MASK; + } +} + +bool COMP_GetOutputStatus(COMP_Type * COMPx, uint32_t channel) +{ + if ( channel < COMP_CHANNEL_NUM ) + { + if ( 0u != ( COMP_CSR_OUT_MASK & COMPx->CSR[channel] ) ) + { + return true; + } + else + { + return false; /* normal input voltage lower than inverting input. */ + } + } + else + { + return false; + } +} + +void COMP_EnableExtVrefConf(COMP_Type * COMPx, COMP_ExtVrefConf_Type * conf) +{ + if ( NULL == conf ) /* disable the ext vref. */ + { + COMPx->CRV &= ~COMP_CRV_CRVEN_MASK; + } + else /* init & enable ext vref. */ + { + COMPx->CRV = COMP_CRV_CRVSRC (conf->VrefSource) + | COMP_CRV_CRVSEL (conf->Volt) + | COMP_CRV_CRVEN_MASK + ; + } +} + +void COMP_EnableRoundRobinConf(COMP_Type * COMPx, uint32_t channel, COMP_RoundRobinConf_Type * conf) +{ + if ( channel < COMP_CHANNEL_NUM ) + { + if ( NULL == conf ) + { + COMPx->POLL[channel] &= ~COMP_POLL_POLLEN_MASK; + } + else + { + COMPx->POLL[channel] = COMP_POLL_PERIOD(conf->Period) + | COMP_POLL_FIXN(conf->InvInFix) + | COMP_POLL_POLLCH(conf->ChnGroup) + | COMP_POLL_POLLEN_MASK; + ; + } + } +} + +bool COMP_GetRoundRobinOutStatus(COMP_Type * COMPx, uint32_t channel, COMP_InMux_Type pos_in) +{ + if ( channel < COMP_CHANNEL_NUM ) + { + uint32_t flag = COMP_POLL_POUT(1 << ( (uint32_t)pos_in - 1 ) ); + if ( 0 != (COMPx->POLL[channel] & flag ) ) + { + return true; + } + else + { + return false; + } + } + else + { + return false; + } +} + +/* EOF. */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dac.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dac.c new file mode 100644 index 0000000000..93d93c108d --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dac.c @@ -0,0 +1,326 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#include "hal_dac.h" + +void DAC_Init(DAC_Type * DACx, uint32_t channel, DAC_Init_Type * init) +{ + uint32_t cr = 0u; + + cr = DACx->CR & ~(( DAC_CR_BOFF1_MASK + | DAC_CR_TEN1_MASK + | DAC_CR_TSEL1_MASK + ) << (channel<<4u)); /* Calculate the shift and clear the indicated bit. */ + + /* Enable Output Buffer. */ + if (init->EnableOutBuf == false) + { + cr |= (DAC_CR_BOFF1_MASK << (channel<<4u)); + } + + /* Trigger Source. */ + if (init->TrgSource < DAC_TrgSource_None) + { + cr |= ((DAC_CR_TEN1_MASK | DAC_CR_TSEL1(init->TrgSource)) << (channel<<4u)); + } + + DAC->CR = cr; +} + +void DAC_Enable(DAC_Type * DACx, uint32_t channel, bool enable) +{ + if (enable) + { + DACx->CR |= (DAC_CR_EN1_MASK << (channel << 4u)); + } + else + { + DACx->CR &= ~(DAC_CR_EN1_MASK << (channel << 4u)); + } +} + +uint32_t DAC_GetData(DAC_Type * DACx, uint32_t channel) +{ + uint32_t ret = 0u; + + if(channel == DAC_CHN_1) + { + ret = (DACx->DOR1 & DAC_DOR1_DACC1DOR_MASK); + } + else if (channel == DAC_CHN_2) + { + ret = (DACx->DOR2 & DAC_DOR2_DACC2DOR_MASK); + } + + return ret; +} + +uint32_t DAC_PutData(DAC_Type * DACx, uint32_t channel, uint32_t value, DAC_Align_Type align) +{ + uint32_t ret = 0u; + + switch (align) + { + case DAC_Align_8b_Dual: + { + DAC_PutDualChannelData8bRightAlign(DACx, value); + ret = DAC_GetData(DACx, DAC_CHN_1) | ( DAC_GetData(DACx, DAC_CHN_2) << 16u); + break; + } + case DAC_Align_8b_Right: + { + DAC_PutData8bRightAlign(DACx, channel, value); + ret = DAC_GetData(DACx, channel); + break; + } + case DAC_Align_12b_Left: + { + DAC_PutData12bLeftAlign(DACx, channel, value); + ret = DAC_GetData(DACx, channel); + break; + } + case DAC_Align_12b_Right: + { + DAC_PutData12bRightAlign(DACx, channel, value); + ret = DAC_GetData(DACx, channel); + break; + } + case DAC_Align_12b_Dual_Left: + { + DAC_PutDualChannelData12bLeftAlign(DACx, value); + ret = DAC_GetData(DACx, DAC_CHN_1) + | ( DAC_GetData(DACx, DAC_CHN_2) << 16u); + break; + } + case DAC_Align_12b_Dual_Right: + { + DAC_PutDualChannelData12bRightAlign(DACx, value); + ret = DAC_GetData(DACx, DAC_CHN_1) + | ( DAC_GetData(DACx, DAC_CHN_2) << 16u); + break; + } + default: + break; + } + return ret; +} + +void DAC_EnableAddNoise(DAC_Type * DACx, uint32_t channel, DAC_AddNoise_Init_Type * init) +{ + if (init == NULL) + { + DAC->CR &= ~(DAC_CR_WAVE1_MASK << (channel << 4u)); + } + else + { + DAC->CR |= (( DAC_CR_WAVE1(1u) /* Noise wave need to set WAVEx = 01. */ + | DAC_CR_MAMP1(init->AddNoise) + ) << (channel << 4u)); + } +} + +void DAC_EnableAddTriangle(DAC_Type * DACx, uint32_t channel, DAC_AddTriangle_Init_Type * init) +{ + if (init == NULL) + { + DAC->CR &= ~(DAC_CR_WAVE1_MASK << (channel << 4u)); + } + else + { + DAC->CR |= (( DAC_CR_WAVE1(2u) /* Noise wave need to set WAVEx = 1x. */ + | DAC_CR_MAMP1(init->AddTriangle) + ) << (channel << 4u)); + } +} + +void DAC_EnableDMA(DAC_Type * DACx, uint32_t channel, bool enable) +{ + if (enable) + { + DACx->CR |= (DAC_CR_DMAEN1_MASK << (channel<<4u)); + } + else + { + DACx->CR &= ~(DAC_CR_DMAEN1_MASK << (channel<<4u)); + } +} + +void DAC_DoSwTrigger(DAC_Type * DACx, uint32_t channel) +{ + DACx->SWTRIGR |= (DAC_SWTRIGR_SWTRIG1_MASK << channel); +} + +void DAC_DoDualChannelSwTrigger(DAC_Type * DACx) +{ + DACx->SWTRIGR |= DAC_SWTRIGR_SWTRIG1_MASK + | DAC_SWTRIGR_SWTRIG2_MASK + ; +} + +uint32_t DAC_GetDataRegAddr(DAC_Type * DACx, uint32_t channel, DAC_Align_Type align) +{ + uint32_t ret = 0u; + + switch (align) + { + case DAC_Align_8b_Dual: + { + ret = DAC_GetDualChannelData8bRegAddr(DACx); + break; + } + case DAC_Align_8b_Right: + { + ret = DAC_GetData8bRegAddr(DACx, channel); + break; + } + case DAC_Align_12b_Left: + { + ret = DAC_GetData12bLeftRegAddr(DACx, channel); + break; + } + case DAC_Align_12b_Right: + { + ret = DAC_GetData12bRightRegAddr(DACx, channel); + break; + } + case DAC_Align_12b_Dual_Left: + { + ret = DAC_GetDualChannelData12bLeftRegAddr(DACx); + break; + } + case DAC_Align_12b_Dual_Right: + { + ret = DAC_GetDualChannelData12bRightRegAddr(DACx); + break; + } + default: + break; + } + return ret; +} + +/* input value bit[7:0]. 12b output: xxxxxxxx0000. */ +void DAC_PutData8bRightAlign(DAC_Type * DACx, uint32_t channel, uint32_t value) +{ + if (channel == DAC_CHN_1) + { + DACx->DHR8R1 = value; + } + else if (channel == DAC_CHN_2) + { + DACx->DHR8R2 = value; + } +} + +/* input value bit[15:4]. 12b output: xxxxxxxxxxxx. */ +void DAC_PutData12bLeftAlign(DAC_Type * DACx, uint32_t channel, uint32_t value) +{ + if (channel == DAC_CHN_1) + { + DACx->DHR12L1 = value; + } + else if (channel == DAC_CHN_2) + { + DACx->DHR12L2 = value; + } +} + +/* input value bit[11:0], 12b output: xxxxxxxxxxxx. */ +void DAC_PutData12bRightAlign(DAC_Type * DACx, uint32_t channel, uint32_t value) +{ + if (channel == DAC_CHN_1) + { + DACx->DHR12R1 = value; + } + else if (channel == DAC_CHN_2) + { + DACx->DHR12R2 = value; + } +} + +/* bit[15:8] for channel 2, bit[7:0] for channel 1. */ +void DAC_PutDualChannelData8bRightAlign(DAC_Type * DACx, uint32_t value) +{ + DACx->DHR8RD = value; +} + +/* bit[31:16] for channel 2, bit[15:0] for channel 1. */ +void DAC_PutDualChannelData12bLeftAlign(DAC_Type * DACx, uint32_t value) +{ + DACx->DHR12LD = value; +} + +/* bit[31:16] for channel 2, bit[15:0] for channel 1. */ +void DAC_PutDualChannelData12bRightAlign(DAC_Type * DACx, uint32_t value) +{ + DACx->DHR12RD = value; +} + +uint32_t DAC_GetData8bRegAddr(DAC_Type * DACx, uint32_t channel) +{ + uint32_t ret = 0u; + + if (channel == DAC_CHN_1) + { + ret = (uint32_t)(&(DACx->DHR8R1)); + } + else if (channel == DAC_CHN_2) + { + ret = (uint32_t)(&(DACx->DHR8R2)); + } + + return ret; +} + +uint32_t DAC_GetData12bLeftRegAddr(DAC_Type * DACx, uint32_t channel) +{ + uint32_t ret = 0u; + + if (channel == DAC_CHN_1) + { + ret = (uint32_t)(&(DACx->DHR12L1)); + } + else if (channel == DAC_CHN_2) + { + ret = (uint32_t)(&(DACx->DHR12L2)); + } + + return ret; +} + +uint32_t DAC_GetData12bRightRegAddr(DAC_Type * DACx, uint32_t channel) +{ + uint32_t ret = 0; + + if (channel == DAC_CHN_1) + { + ret = (uint32_t)(&(DACx->DHR12R1)); + } + else if (channel == DAC_CHN_2) + { + ret = (uint32_t)(&(DACx->DHR12R2)); + } + + return ret; +} + +uint32_t DAC_GetDualChannelData8bRegAddr(DAC_Type * DACx) +{ + return (uint32_t)(&(DACx->DHR8RD)); +} + +uint32_t DAC_GetDualChannelData12bLeftRegAddr(DAC_Type * DACx) +{ + return (uint32_t)(&(DACx->DHR12LD)); +} + +uint32_t DAC_GetDualChannelData12bRightRegAddr(DAC_Type * DACx) +{ + return (uint32_t)(&(DACx->DHR12RD)); +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dma.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dma.c new file mode 100644 index 0000000000..e04d0797e8 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_dma.c @@ -0,0 +1,86 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_dma.h" + +/* clear all the interrupt enables and disable the dma channel. */ +uint32_t DMA_InitChannel(DMA_Type * DMAx, uint32_t channel, DMA_Channel_Init_Type * init) +{ + uint32_t ccr = 0u; + + if ( (init->XferMode == DMA_XferMode_MemoryToPeriph) + || (init->XferMode == DMA_XferMode_MemoryToPeriphBurst) ) + { + ccr |= DMA_CCR_DIR_MASK; + } + + if ( (init->XferMode == DMA_XferMode_PeriphToMemoryBurst) + || (init->XferMode == DMA_XferMode_MemoryToPeriphBurst) ) + { + ccr |= DMA_CCR_MEM2MEM_MASK; + } + + if (init->ReloadMode == DMA_ReloadMode_AutoReload) + { + ccr |= DMA_CCR_ARE_MASK; + } + else if (init->ReloadMode == DMA_ReloadMode_AutoReloadContinuous) + { + ccr |= (DMA_CCR_ARE_MASK | DMA_CCR_CIRC_MASK); + } + + ccr |= DMA_CCR_PINC(init->PeriphAddrIncMode) + | DMA_CCR_MINC(init->MemAddrIncMode) + | DMA_CCR_PSIZE(init->XferWidth) + | DMA_CCR_MSIZE(init->XferWidth) + | DMA_CCR_PL(init->Priority) + ; + + DMAx->CH[channel].CCR = ccr; + DMAx->CH[channel].CNDTR = init->XferCount; + DMAx->CH[channel].CPAR = init->PeriphAddr; + DMAx->CH[channel].CMAR = init->MemAddr; + + return 0u; +} + +void DMA_EnableChannelInterrupts(DMA_Type * DMAx, uint32_t channel, uint32_t interrupts, bool enable) +{ + if (enable) + { + DMAx->CH[channel].CCR |= (interrupts & 0xEu); + } + else + { + DMAx->CH[channel].CCR &= ~(interrupts & 0xEu); + } +} + +uint32_t DMA_GetChannelInterruptStatus(DMA_Type * DMAx, uint32_t channel) +{ + return (DMAx->ISR >> (channel * 4u)) & 0xFu; +} + +void DMA_ClearChannelInterruptStatus(DMA_Type * DMAx, uint32_t channel, uint32_t interrupts) +{ + DMAx->IFCR = ( (interrupts & 0xFu) << (channel * 4u) ); +} + +void DMA_EnableChannel(DMA_Type * DMAx, uint32_t channel, bool enable) +{ + if (enable) + { + DMAx->CH[channel].CCR |= DMA_CCR_EN_MASK; + } + else + { + DMAx->CH[channel].CCR &= ~DMA_CCR_EN_MASK; + } +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_exti.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_exti.c new file mode 100644 index 0000000000..fceaf3b9c8 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_exti.c @@ -0,0 +1,74 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#include "hal_exti.h" + +void EXTI_EnableLineInterrupt(EXTI_Type * EXTIx, uint32_t lines, bool enable) +{ + if (enable) + { + EXTIx->IMR |= lines; + } + else + { + EXTIx->IMR &= ~ lines; + } +} + +void EXTI_EnableLineEvent(EXTI_Type * EXTIx, uint32_t lines, bool enable) +{ + if (enable) + { + EXTIx->EMR |= lines; + } + else + { + EXTIx->EMR &= ~ lines; + } +} + +void EXTI_SetTriggerIn(EXTI_Type * EXTIx, uint32_t lines, EXTI_TriggerIn_Type trgin) +{ + switch (trgin) + { + case EXTI_TriggerIn_Disable: + EXTIx->RTSR &= ~ lines; + EXTIx->FTSR &= ~ lines; + break; + case EXTI_TriggerIn_RisingEdge: + EXTI->RTSR |= lines; + EXTIx->FTSR &= ~ lines; + break; + case EXTI_TriggerIn_FallingEdge: + EXTI->RTSR &= ~ lines; + EXTI->FTSR |= lines; + break; + case EXTI_TriggerIn_BothEdges: + EXTI->RTSR |= lines; + EXTI->FTSR |= lines; + break; + default: + break; + } +} + +void EXTI_DoSwTrigger(EXTI_Type * EXTIx, uint32_t lines) +{ + EXTIx->SWIER = lines; +} + +uint32_t EXTI_GetLineStatus(EXTI_Type * EXTIx) +{ + return EXTIx->PR; +} + +void EXTI_ClearLineStatus(EXTI_Type * EXTIx, uint32_t lines) +{ + EXTIx->PR |= lines; +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_fsmc.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_fsmc.c new file mode 100644 index 0000000000..49b596eeef --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_fsmc.c @@ -0,0 +1,115 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#include "hal_fsmc.h" + +const uint32_t FSMC_BankBases[] = +{ + FSMC_BANK0_BASE, + FSMC_BANK1_BASE, + FSMC_BANK2_BASE, + FSMC_BANK3_BASE +}; + +void FSMC_Init(FSMC_Type * FSMCx, FSMC_Init_Type * init) +{ + FSMCx->SMSKR0 = ( (FSMCx->SMSKR0 & ~(FSMC_SMSKR0_MEMSIZE_MASK | FSMC_SMSKR0_MEMTYPE_MASK) ) + | FSMC_SMSKR0_MEMSIZE(init->MemSize) + | FSMC_SMSKR0_MEMTYPE(init->MemType) ) + ; +} + +void FSMC_SetConf(FSMC_Type * FSMCx, uint32_t index, FSMC_Conf_Type * init) +{ + if (index >= FSMC_SMTMGR_REG_NUM) + { + return; + } + FSMCx->SMTMGRSET[index] = FSMC_SMTMGRSET_TRC(init->ReadPeriod) + | FSMC_SMTMGRSET_TAS(init->AddrSetTime) + | FSMC_SMTMGRSET_TWR(init->WriteHoldTime) + | FSMC_SMTMGRSET_TWP(init->WritePeriod) + | FSMC_SMTMGRSET_READYMODE(init->ReadySignal) + | FSMC_SMTMGRSET_SMREADPIPE(init->SMReadPipe) + ; + switch (index) + { + case 0u: + FSMCx->SMCTLR = ( (FSMCx->SMCTLR & ~FSMC_SMCTLR_SMDATAWIDTHSET0_MASK) + | FSMC_SMCTLR_SMDATAWIDTHSET0(init->BusWidth) ) + ; + break; + case 1u: + FSMCx->SMCTLR = ( (FSMCx->SMCTLR & ~FSMC_SMCTLR_SMDATAWIDTHSET1_MASK) + | FSMC_SMCTLR_SMDATAWIDTHSET1(init->BusWidth) ) + ; + break; + case 2u: + FSMCx->SMCTLR = ( (FSMCx->SMCTLR & ~FSMC_SMCTLR_SMDATAWIDTHSET2_MASK) + | FSMC_SMCTLR_SMDATAWIDTHSET2(init->BusWidth) ) + ; + break; + default: + break; + } +} + + /* only last enabled bankn is available. */ +void FSMC_EnableConf(FSMC_Type * FSMCx, uint32_t index) +{ + if (index >= FSMC_SMTMGR_REG_NUM) + { + return; + } + FSMCx->SMSKR0 = ( (FSMCx->SMSKR0 & ~FSMC_SMSKR0_REGSELECT_MASK) + | FSMC_SMSKR0_REGSELECT(index) ) + ; +} + +void FSMC_PutData32(FSMC_Type * FSMCx, uint32_t bankn, uint32_t offset, uint32_t data) +{ + (void)FSMCx; + *( (uint32_t *)(FSMC_BankBases[bankn] + offset) ) = data; +} + +uint32_t FSMC_GetData32(FSMC_Type * FSMCx, uint32_t bankn, uint32_t offset) +{ + (void)FSMCx; + return (*( (uint32_t *)(FSMC_BankBases[bankn] + offset) ) ); +} + +uint32_t FSMC_GetXferDataRegAddr(FSMC_Type *FSMCx, uint32_t bankn, uint32_t offset) +{ + (void)FSMCx; + return (FSMC_BankBases[bankn] + offset); +} + +void FSMC_PutData16(FSMC_Type * FSMCx, uint32_t bankn, uint32_t offset, uint16_t data) +{ + (void)FSMCx; + *( (uint16_t *)(FSMC_BankBases[bankn] + offset) ) = data; +} + +uint16_t FSMC_GetData16(FSMC_Type * FSMCx, uint32_t bankn, uint32_t offset) +{ + (void)FSMCx; + return (*( (uint16_t *)(FSMC_BankBases[bankn] + offset) ) ); +} + +void FSMC_PutData8(FSMC_Type * FSMCx, uint32_t bankn, uint32_t offset, uint8_t data) +{ + (void)FSMCx; + *( (uint8_t *)(FSMC_BankBases[bankn] + offset) ) = data; +} + +uint8_t FSMC_GetData8(FSMC_Type * FSMCx, uint32_t bankn, uint32_t offset) +{ + (void)FSMCx; + return (*( (uint8_t *)(FSMC_BankBases[bankn] + offset) ) ); +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_gpio.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_gpio.c new file mode 100644 index 0000000000..dc291b83af --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_gpio.c @@ -0,0 +1,149 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_gpio.h" + +void GPIO_Init(GPIO_Type * GPIOx, GPIO_Init_Type * init) +{ + uint8_t idx; + uint8_t i; + uint32_t pin; + __IO uint32_t * addr; + + /* 1x. */ + uint32_t dat = init->PinMode & 0xFu; + if (init->PinMode & 0x10u) + { + dat |= init->Speed; + } + + /* 0x. */ + addr = &(GPIOx->CRL); + for (i = 0u; i < 8u; i++) + { + idx = i * 4u; + if ( (init->Pins) & (1u << i) ) + { + *addr = ( *addr & ~(0xFu << idx) ) | (dat << idx); + } + } + + addr = &(GPIOx->CRH); + pin = init->Pins >> 8u; + for (i = 0u; i < 8u; i++) + { + idx = i * 4u; + if ( pin & (1u << i) ) + { + *addr = ( *addr & ~(0xFu << idx) ) | (dat << idx); + } + } + + /* 2x,4x. */ + if (init->PinMode == GPIO_PinMode_In_PullDown) + { + GPIOx->BRR |= init->Pins; + } + else if (init->PinMode == GPIO_PinMode_In_PullUp) + { + GPIOx->BSRR |= init->Pins; + } +} + +bool GPIO_ReadInDataBit(GPIO_Type * GPIOx, uint16_t pin) +{ + return (GPIOx->IDR & pin); +} + +uint16_t GPIO_ReadInData(GPIO_Type * GPIOx) +{ + return (uint16_t)(GPIOx->IDR); +} + +bool GPIO_ReadOutDataBit(GPIO_Type * GPIOx, uint16_t pins) +{ + return (GPIOx->ODR & pins); +} + +uint16_t GPIO_ReadOutData(GPIO_Type * GPIOx) +{ + return (uint16_t)GPIOx->ODR; +} + +void GPIO_SetBits(GPIO_Type * GPIOx, uint16_t pins) +{ + GPIOx->BSRR = pins; +} + +void GPIO_ClearBits(GPIO_Type * GPIOx, uint16_t pins) +{ + GPIOx->BRR = pins; +} + +void GPIO_WriteBit(GPIO_Type * GPIOx, uint16_t pins, uint16_t val) +{ + (val != 0u) ? (GPIOx->BSRR = pins) : (GPIOx->BRR = pins); +} + +void GPIO_WriteBits(GPIO_Type * GPIOx, uint16_t val) +{ + GPIOx->ODR = val; +} + +void GPIO_PinLock(GPIO_Type * GPIOx, uint16_t pins, bool enable_lock) +{ + (enable_lock) ? (GPIOx->LCKR |= pins) : (GPIOx->LCKR &= ~pins); +} + +void GPIO_PinLockConf(GPIO_Type * GPIOx, uint16_t pins) +{ + GPIOx->LCKR = GPIO_LCKR_LCKK_MASK | GPIO_LCKR_LCK(pins); + GPIOx->LCKR = pins; + GPIOx->LCKR = GPIO_LCKR_LCKK_MASK | GPIO_LCKR_LCK(pins); + GPIOx->LCKR; + GPIOx->LCKR; +} + +void GPIO_PinAFConf(GPIO_Type * GPIOx, uint16_t pins, uint8_t af) +{ + uint32_t shift = 0u; + uint32_t idx = 0u; + uint32_t val = GPIOx->AFRL; + while (idx < 8u) + { + if ( ( (1u << idx) & pins) != 0u ) + { + shift = idx * 4u; + val &= ~(0xFu << shift); + val |= (uint32_t)af << shift; + } + idx++; + } + GPIOx->AFRL = val; + + val = GPIOx->AFRH; + while (idx < 16u) + { + if ( ( (1u << idx) & pins) != 0u ) + { + shift = (idx - 8u) * 4u; + val &= ~(0xFu << shift); + val |= (uint32_t)af << shift; + } + idx++; + } + GPIOx->AFRH = val; +} + +void GPIO_PortAFConfig(GPIO_Type * GPIOx, uint32_t af_high, uint32_t af_low) +{ + GPIOx->AFRL = af_low; + GPIOx->AFRH = af_high; +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_i2c.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_i2c.c new file mode 100644 index 0000000000..b17b774b18 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_i2c.c @@ -0,0 +1,357 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_i2c.h" + +/* Configure I2C speed to ordinary speed. */ +static bool I2C_CalcBandrate(I2C_Type * I2Cx, uint32_t clk, uint32_t bandrate) +{ + /* + * SCLH = (xSHR + 12) * I2C_CLK + tSYNC1; + * SCLL = (xSLR + 1) * I2C_CLK + tSYNC2; + * tSYNC1 & tSYNC2 equal 0 ~ 1 clk. + */ + if ( (clk / 24u) < bandrate ) /* the system clock cannot meet the baud rate requirement. */ + { + return false; + } + else + { + uint32_t tmp = clk / bandrate; + I2Cx->SSHR = tmp / 2u - 12u; /* Configure high level count in normal speed. */ + I2Cx->SSLR = tmp / 2u - 1u; /* Configure low level count in normal speed. */ + I2Cx->FSHR = tmp / 2u - 14u; /* Configure high level count in fast speed. */ + I2Cx->FSLR = tmp / 2u - 3u; /* Configure low level count in fast speed. */ + return true; + } +} + +/* Initialize I2C, Initialization failure return false, Initialization success return true. */ +bool I2C_InitMaster(I2C_Type * I2Cx, I2C_Master_Init_Type * init) +{ + I2Cx->ENR &= ~I2C_ENR_ENABLE_MASK; /* Disable I2C. */ + + if ( !I2C_CalcBandrate(I2Cx, init->ClockFreqHz, init->BaudRate) ) /* The system clock cannot meet the baud rate requirement. */ + { + return false; + } + + I2Cx->CR = I2C_CR_SPEED(1u); + + /* Setup I2C. */ + I2Cx->CR &= ~I2C_CR_MASTER10_MASK; /* Address format. */ + I2Cx->CR |= I2C_CR_RESTART_MASK /* Generate restart signal. */ + | I2C_CR_DISSLAVE_MASK /* Disable slave module. */ + | I2C_CR_REPEN_MASK /* Enable sending restart condition. */ + | I2C_CR_EMPINT_MASK /* Control tx_empty interrupt generation. */ + | I2C_CR_MASTER_MASK; /* Enable master module. */ + + I2Cx->IMR = 0u; /* Close all interrupts. */ + I2Cx->RXTLR = 0u; /* Configure the sending receive value. */ + I2Cx->TXTLR = 0u; /* Configure the sending threshold value. */ + return true; /* Initialize I2C succeeded, return true. */ +} + +/* Enable I2C. */ +void I2C_Enable(I2C_Type * I2Cx, bool enable) +{ + if (enable) + { + I2Cx->ENR |= I2C_ENR_ENABLE_MASK; + } + else + { + I2Cx->ENR &= ~I2C_ENR_ENABLE_MASK; + } +} + +/* Configuration the target device address. */ +void I2C_SetTargetAddr(I2C_Type * I2Cx, uint8_t addr) +{ + I2Cx->TAR = I2C_TAR_ADDR(addr); +} + +/* Get I2C target device address. */ +uint16_t I2C_GetTargetAddr(I2C_Type * I2Cx) +{ + return (I2Cx->TAR & I2C_TAR_ADDR_MASK); +} + +/* Put data to target device. */ +void I2C_PutData(I2C_Type * I2Cx, uint8_t val) +{ + I2Cx->DR = I2C_DR_DAT(val); +} + +/* Control read-write bit to prepare to read data. */ +void I2C_PrepareToGetData(I2C_Type * I2Cx) +{ + I2Cx->DR = I2C_DR_CMD_MASK; +} + +/* Get the data received by target device. */ +uint8_t I2C_GetData(I2C_Type * I2Cx) +{ + return ( (uint8_t)I2Cx->DR ); +} + +/* Get the current status flags of the I2C module. */ +uint32_t I2C_GetStatus(I2C_Type * I2Cx) +{ + return I2Cx->SR; +} + +/* Prepare for the stop, when transfer finish. */ +void I2C_Stop(I2C_Type * I2Cx) +{ + I2Cx->ENR |= I2C_ENR_ABORT_MASK; /* Prepare for the stop. */ + I2Cx->TXABRT; /* Read register to release tx fifo. */ +} + +/* Enable I2C interrupt. */ +void I2C_EnableInterrupts(I2C_Type * I2Cx, uint32_t interrupts, bool enable) +{ + if (enable) + { + I2Cx->IMR |= interrupts; + } + else + { + I2Cx->IMR &= ~interrupts; + } +} + +/* Get the current enabled interrupts the I2C module. */ +uint32_t I2C_GetEnabledInterrupts(I2C_Type * I2Cx) +{ + return I2Cx->IMR; +} + +/* Get the I2C interrupt status flags of the I2C module. */ +uint32_t I2C_GetInterruptStatus(I2C_Type * I2Cx) +{ + return (I2Cx->RAWISR & I2Cx->IMR); /* To ensure that the acquired interrupt is an enabled interrupt. */ +} + +/* Clear I2C interrupt status. */ +void I2C_ClearInterruptStatus(I2C_Type * I2Cx, uint32_t interrupts) +{ + if ( (I2C_INT_RX_UNDER & interrupts) != 0u ) /* Clear receive buffer under status. */ + { + I2Cx->RXUNDER; + } + if ( (I2C_INT_TX_ABORT & interrupts) != 0u ) /* Clear I2C transmit abort status. */ + { + I2Cx->TXABRT; + } + if ( (I2C_INT_ACTIVE & interrupts) != 0u ) /* Clear I2C interface activation status. */ + { + I2Cx->ACTIV; + } + if ( (I2C_INT_STOP & interrupts) != 0u ) /* Clear I2C stop condition detection status. */ + { + I2Cx->STOP; + } + if ( (I2C_INT_START & interrupts) != 0u ) /* Clear I2C start condition detection status. */ + { + I2Cx->START; + } +} + +/* Performs polling tx. */ +bool I2C_MasterWriteBlocking(I2C_Type * I2Cx, I2C_MasterXfer_Type * xfer) +{ + /* Put register address. */ + I2C_PutData(I2Cx, xfer->TxBuf[0u]); + + uint32_t waittime1 = xfer->WaitTimes; + /* Wait to tx fifo empty. */ + while ( (0u == (I2C_GetStatus(I2Cx) & I2C_STATUS_TX_EMPTY) ) && (0u != waittime1) ) + { + waittime1--; + } + if (0u == waittime1) /* I2C write register address timeout. */ + { + return false; + } + + uint32_t waittime2 = xfer->WaitTimes; + /* Write data to target device. */ + for (uint32_t i = 1u; i < xfer->TxLen; i++) + { + I2C_PutData(I2Cx, xfer->TxBuf[i]); + + while ( ( 0u == (I2C_GetStatus(I2Cx) & I2C_STATUS_TX_EMPTY) ) && (0u != waittime2) ) /* Wait to tx fifo empty. */ + { + waittime2--; + } + if (0u == waittime2) /* I2C write timeout. */ + { + return false; + } + } + + I2C_Stop(I2Cx); /* Prepare to stop send data. */ + + uint32_t waittime3 = xfer->WaitTimes; + /* Wait to I2C not active, which means stop is taking effect. */ + while ( (I2C_GetStatus(I2Cx) & I2C_STATUS_ACTIVE) && (0u != waittime3) ) + { + waittime3--; + } + if (0u == waittime3) /* The wait operation is timeout. */ + { + return false; + } + + /* Clear fifo and flags. */ + I2C1->ICR; + I2C1->TXABRT; + return true; +} + +/* Performs polling rx. */ +bool I2C_MasterReadBlocking(I2C_Type * I2Cx, I2C_MasterXfer_Type * xfer) +{ + I2C_PutData(I2Cx, xfer->TxBuf[0u]); /* Put device register address. */ + + uint32_t waittime1 = xfer->WaitTimes; + while ( ( 0u == (I2C_GetStatus(I2Cx) & I2C_STATUS_TX_EMPTY) ) && (0u != waittime1) ) /* Wait to tx fifo empty. */ + { + waittime1--; + } + if (0u == waittime1) + { + return false; + } + + /* read data from target device. */ + for (uint32_t i = 0u; i < xfer->RxLen; i++) + { + I2C_PrepareToGetData(I2Cx); /* Swich read-write bit, prepare to get data. */ + + while ( 0u == (I2C_GetStatus(I2Cx) & I2C_STATUS_RX_NOTEMPTY) ) /* Wait to rx fifo not empty. */ + { + if ( 0u == (I2C_GetStatus(I2Cx) & I2C_STATUS_ACTIVE) ) /* Receive is active. */ + { + return false; + } + } + xfer->RxBuf[i] = I2C_GetData(I2Cx); + } + + I2C_Stop(I2Cx); /* Prepare to stop I2C. */ + + uint32_t waittime2 = xfer->WaitTimes; + while ( (I2C_GetStatus(I2Cx) & I2C_STATUS_ACTIVE) && (0u != waittime2) ) /* Wait I2C not active, which means stop being effective. */ + { + waittime2--; + } + if (0u == waittime2) + { + return false; + } + + /* Clear fifo and flags. */ + I2C1->ICR; + I2C1->TXABRT; + + return true; +} + +/* I2C master interrupt transfer of the I2C module. */ +void I2C_MasterXfer(I2C_Type * I2Cx, I2C_MasterXfer_Type * xfer) +{ + I2C_PutData(I2Cx, (uint8_t)xfer->TxBuf[0u]); /* Put target register address. */ + I2C_EnableInterrupts(I2Cx, I2C_INT_TX_EMPTY | I2C_INT_TX_ABORT | I2C_INT_STOP, true); /* Enable tx required interrupt. */ + xfer->TxIdx = 1u; /* One data has been sent. */ + xfer->RxIdx = 0u; + xfer->TxLen--; +} + +/* I2C Master handler. */ +void I2C_MasterXferHandler(I2C_Type * I2Cx, I2C_MasterXfer_Type * xfer, uint32_t interrupts) +{ + if ( 0u != (interrupts & I2C_INT_TX_ABORT) ) /* Early termination of program. */ + { + I2C_EnableInterrupts(I2Cx, I2C_INT_TX_EMPTY | I2C_INT_TX_ABORT | I2C_INT_STOP, false); /* Clear the interrupt used for tx. */ + if (NULL != xfer->AbortCallback) + { + xfer->AbortCallback(xfer); /* Use abort call back. */ + } + } + else if ( 0u != (interrupts & I2C_INT_TX_EMPTY) ) /* Tx fifo is empty, can send data. */ + { + if (I2C_Direction_Rx == xfer->Direction) /* The current operation is receive, the register address has been sent. */ + { + I2C_EnableInterrupts(I2Cx, I2C_INT_TX_EMPTY | I2C_INT_TX_ABORT, false); /* Clear tx interrupt. */ + I2C_EnableInterrupts(I2Cx, I2C_INT_RX_NOTEMPTY, true); /* Enable receive required interrupt. */ + if (0u != xfer->RxLen) /* The data to be received is not 0. */ + { + I2C_PrepareToGetData(I2Cx); /* Prepare to get data. */ + xfer->RxLen--; + } + else + { + I2C_Stop(I2Cx); /* No more transmition, prepare to stop. */ + } + } + else + { + if (0u == xfer->TxLen) /* Tx finish. */ + { + I2C_EnableInterrupts(I2Cx, I2C_INT_TX_EMPTY | I2C_INT_TX_ABORT, false); /* Clear Tx interrupt. */ + I2C_Stop(I2Cx); /* Prepare to stop. */ + } + else + { + xfer->TxLen--; + I2C_PutData(I2Cx, xfer->TxBuf[xfer->TxIdx++]); /* Tx is not over, continue to put data. */ + } + } + } + else if ( 0u != (interrupts & I2C_INT_RX_NOTEMPTY) ) /* Receive interrupt. */ + { + if (0u == xfer->RxLen) /* Receive finish. */ + { + xfer->RxBuf[xfer->RxIdx++] = I2C_GetData(I2Cx); /* Get last data from I2C bus. */ + I2C_EnableInterrupts(I2Cx, I2C_INT_RX_NOTEMPTY, false); /* Clear receive interrupt. */ + I2C_Stop(I2Cx); /* Prepare to stop. */ + } + else + { + xfer->RxLen--; /* Current count length count -1. */ + xfer->RxBuf[xfer->RxIdx++] = I2C_GetData(I2Cx); /* Receive is not over, continue to get data. */ + I2C_PrepareToGetData(I2Cx); /* Prepare to get data. */ + } + } + else if ( 0u != (interrupts & I2C_INT_STOP) ) /* Xfer stop. */ + { + I2C_EnableInterrupts(I2Cx, I2C_INT_STOP, false); /* Clear stop interrupt. */ + if ( (0u != xfer->TxLen) || (0u != xfer->RxLen) ) /* The transmission was not completed but terminated. */ + { + if (NULL != xfer->AbortCallback) + { + xfer->AbortCallback(xfer); /* Early termination of program, abort callback. */ + I2C1->ICR; + I2C1->TXABRT; /* Clear FIFO. */ + } + } + else + { + if (NULL != xfer->DoneCallback) + { + xfer->DoneCallback(xfer); /* Transmission finish and stop, xfer done callback. */ + I2C1->ICR; + I2C1->TXABRT; /* Clear FIFO. */ + } + } + } +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_iwdg.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_iwdg.c new file mode 100644 index 0000000000..08125aa54d --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_iwdg.c @@ -0,0 +1,59 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_iwdg.h" + +void IWDG_Init(IWDG_Type * IWDGx, IWDG_Init_Type * init) +{ + if ( NULL != init ) + { + IWDGx->KR = IWDG_KEY_UNLOCK; + IWDGx->PR = init->Prescaler; + + IWDGx->KR = IWDG_KEY_UNLOCK; + IWDGx->RLR = init->Relaod; + + IWDG_DoReload(IWDGx); + } +} + +void IWDG_Start(IWDG_Type * IWDGx) +{ + IWDGx->KR = IWDG_KEY_ENABLE; +} + +uint32_t IWDG_GetStatus(IWDG_Type * IWDGx) +{ + return IWDGx->SR; +} + +void IWDG_DoReload(IWDG_Type * IWDGx) +{ + IWDGx->KR = IWDG_KEY_RELOAD; +} + +void IWDG_EnableInterrupts(IWDG_Type * IWDGx, uint32_t interrupts, bool enable) +{ + if( (true == enable ) && (IWDG_INT_ALMOST_TIMEOUT == interrupts) ) + { + IWDGx->CR |= IWDG_CR_IRQSEL_MASK; + } + else + { + /* if IWDG_EnableInterrupts interrupt was enabled, only MCU reset can close it. */ + } +} + +void IWDG_ClearStatus(IWDG_Type * IWDGx, uint32_t status) +{ + if( 0u != ( status & IWDG_CR_IRQCLR_MASK ) ) + { + IWDGx->CR |= IWDG_CR_IRQCLR_MASK; + } +} + +/* EOF. */ \ No newline at end of file diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rcc.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rcc.c new file mode 100644 index 0000000000..ed723a97c9 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rcc.c @@ -0,0 +1,72 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#include "hal_common.h" +#include "hal_rcc.h" + +void RCC_EnableAHB1Periphs(uint32_t ahb1_periphs, bool enable) +{ + (enable) ? (RCC->AHB1ENR |= ahb1_periphs) : (RCC->AHB1ENR &= ~ahb1_periphs); +} + +void RCC_EnableAHB2Periphs(uint32_t ahb2_periphs, bool enable) +{ + (enable) ? (RCC->AHB2ENR |= ahb2_periphs) : (RCC->AHB2ENR &= ~ahb2_periphs); +} + +void RCC_EnableAHB3Periphs(uint32_t ahb3_periphs, bool enable) +{ + (enable) ? (RCC->AHB3ENR |= ahb3_periphs) : (RCC->AHB3ENR &= ~ahb3_periphs); +} + +void RCC_EnableAPB1Periphs(uint32_t apb1_periphs, bool enable) +{ + (enable) ? (RCC->APB1ENR |= apb1_periphs) : (RCC->APB1ENR &= ~apb1_periphs); +} + +void RCC_EnableAPB2Periphs(uint32_t apb2_periphs, bool enable) +{ + (enable) ? (RCC->APB2ENR |= apb2_periphs) : (RCC->APB2ENR &= ~apb2_periphs); +} + +void RCC_ResetAHB1Periphs(uint32_t ahb1_periphs) +{ + RCC->AHB1RSTR |= ahb1_periphs; + RCC->AHB1RSTR &= ~ahb1_periphs; +} + +void RCC_ResetAHB2Periphs(uint32_t ahb2_periphs) +{ + RCC->AHB2RSTR |= ahb2_periphs; + RCC->AHB2RSTR &= ~ahb2_periphs; +} + +void RCC_ResetAHB3Periphs(uint32_t ahb3_periphs) +{ + RCC->AHB3RSTR |= ahb3_periphs; + RCC->AHB3RSTR &= ~ahb3_periphs; +} + +void RCC_ResetAPB1Periphs(uint32_t apb1_periphs) +{ + RCC->APB1RSTR |= apb1_periphs; + RCC->APB1RSTR &= ~apb1_periphs; +} + +void RCC_ResetAPB2Periphs(uint32_t apb2_periphs) +{ + RCC->APB2RSTR |= apb2_periphs; + RCC->APB2RSTR &= ~apb2_periphs; +} + +void RCC_MCOConf(RCC_MCO_Type source) +{ + RCC->CFGR = (RCC->CFGR & ~RCC_CFGR_MCO_MASK) | RCC_CFGR_MCO(source); +} + +/* EOF. */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rtc.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rtc.c new file mode 100644 index 0000000000..0dca9c2e50 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_rtc.c @@ -0,0 +1,372 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_rtc.h" + +/* Initialize RTC. */ +void RTC_Init(void) +{ + /* Open access rights. */ + RCC->BDCR |= RCC_BDCR_DBP_MASK; + + /* Reset BKP. */ + RCC->BDCR |= RCC_BDCR_BDRST_MASK; + RCC->BDCR &= ~RCC_BDCR_BDRST_MASK; + + /* Enable clock source. */ + RCC->BDCR |= RCC_BDCR_RTCSEL(1u); + RCC->BDCR &= ~RCC_BDCR_LSEON_MASK; + RCC->BDCR |= RCC_BDCR_LSEON_MASK; + + /* Clear register synchronization status. */ + RTC->CRL &= ~RTC_CRL_RSF_MASK; +} + +/* Enable or disable access to RTC and backing registers. */ +void RTC_EnableAccess(bool enable) +{ + if (enable) + { + RCC->BDCR |= RCC_BDCR_DBP_MASK; + } + else + { + RCC->BDCR &= ~RCC_BDCR_DBP_MASK; + } +} + +/* Enable backup domain software reset, the register of BKP is reset by the backup domain, not reset during power reset and system reset. */ +void RTC_EnableReset(bool enable) +{ + if (enable) + { + RCC->BDCR |= RCC_BDCR_BDRST_MASK; + } + else + { + RCC->BDCR &= ~RCC_BDCR_BDRST_MASK; + } +} + +/* Get the current status flags of the RTC module. */ +uint32_t RTC_GetStatus(void) +{ + return RTC->CRL; +} + +/* Clear the status flag of the RTC module. */ +void RTC_ClearStatus(uint32_t status) +{ + RTC->CRL &= ~status; +} + +/* Get RTC clock source status. */ +uint32_t RTC_GetClockStatus(void) +{ + return RCC->BDCR; +} + +/* Enable RTC clock. */ +void RTC_Enable(bool enable) +{ + if (enable) + { + RCC->BDCR |= RCC_BDCR_RTCEN_MASK; + } + else + { + RCC->BDCR &= ~RCC_BDCR_RTCEN_MASK; + } +} + +/* Enable or disable the configuration mode, enable to enter configuration mode, this is a precondition for registers to write data. */ +void RTC_EnableConf(bool enable) +{ + if (enable) + { + RTC->CRL |= RTC_CRL_CNF_MASK; + } + else + { + RTC->CRL &= ~RTC_CRL_CNF_MASK; + } +} + +/* Setup prescaler register, open configration module before put data into RTC register. */ +void RTC_PutPrescalerData(uint32_t div) +{ + RTC->CRL |= RTC_CRL_CNF_MASK; /* Enable the configuration mode. */ + RTC->PRLH = div >> 16u; /* Setup the upper 16-bit value of prescaler. */ + RTC->PRLL = div; /* Setup the lower 16-bit value of prescaler. */ + RTC->CRL &= ~RTC_CRL_CNF_MASK; /* Disable the configuration mode. */ +} + +/* Setup counter register, open configration module before put data into RTC register. */ +void RTC_PutCounterData(uint32_t cnt) +{ + RTC->CRL |= RTC_CRL_CNF_MASK; /* Enable the configuration mode. */ + RTC->CNTH = cnt >> 16u; /* Setup the upper 16-bit value of counter. */ + RTC->CNTL = cnt; /* Setup the lower 16-bit value of counter. */ + RTC->CRL &= ~RTC_CRL_CNF_MASK; /* Disable the configuration mode. */ +} + +/* Setup alarm register, open configration module before put data into RTC register. */ +void RTC_PutAlarmData(uint32_t alarm) +{ + RTC->CRL |= RTC_CRL_CNF_MASK; /* Enable the configuration mode. */ + RTC->ALRH = alarm >> 16u; /* Setup the upper 16-bit value of alarm counter. */ + RTC->ALRL = alarm; /* Setup the lower 16-bit value of alarm counter. */ + RTC->CRL &= ~RTC_CRL_CNF_MASK; /* Disable the configuration mode. */ +} + +/* Get the data from counter of I2C module. */ +uint32_t RTC_GetCounterData(void) +{ + return ( (RTC->CNTH << 16u) | RTC->CNTL ); +} + +/* Get alarm count value which is used to alarm interrupt. */ +uint32_t RTC_GetAlarmData(void) +{ + return ( (RTC->ALRH << 16u) | RTC->ALRL); +} + +/* Enable RTC interrupt of RTC module. */ +void RTC_EnableInterrupts(uint32_t interrupts, bool enable) +{ + if (enable) + { + RTC->CRH |= interrupts; + } + else + { + RTC->CRH &= ~interrupts; + } +} + +/* Get the interrupts status flags of the RTC module. */ +uint32_t RTC_GetInterruptStatus(void) +{ + return RTC->CRL; +} + +/* Clear the status of RTC interrupt. */ +void RTC_ClearInterruptStatus(uint32_t interrupts) +{ + RTC->CRL &= ~interrupts; +} + +/* Get RTC interrupt enable status. */ +uint32_t RTC_GetEnabledInterrupts(void) +{ + return RTC->CRH; +} + +/* Judging whether the current year is a leap year, an ordinary leap year or a century leap year. */ +bool RTC_JudgeLeapYear(uint16_t years) +{ + if (years % 4u == 0u) + { + if (years % 100u == 0u) + { + if (years % 400u == 0u) + { + return true; /* Century leap year. */ + } + else + { + return false; + } + } + else + { + return true; /* Ordinary leap year. */ + } + } + else + { + return false; + } +} + +/* Month correction table, used for calculation of month. */ +const uint8_t month_table[12u] = {31u, 28u, 31u, 30u, 31u, 30u, 31u, 31u, 30u, 31u, 30u, 31u}; + +/* Setup initialization time. */ +bool RTC_SetTimeBlocking(RTC_Init_Type * init, RTC_Time_Type * time) +{ + RTC_PutPrescalerData(init->Div); /* Setup prescaler. */ + while ( (0u == (RTC_GetStatus() & RTC_STATUS_OPERATION) ) && (0u != (time->WaitTime--) ) ) /* Wait for write operation finish, only after the end of the previous write operation can new write be performed. */ + { + } + + /* Calculate the total number of seconds of the current configuration time. */ + uint32_t seccnt = 0u; + if ( (init->Years < init->LYears) || (init->Years > init->HYears) ) /* Exceeding the specified year. */ + { + return false; + } + /* Calculate the number of seconds from the lowest years to the current setup years. */ + for (uint16_t years = init->LYears; years < init->Years; years++) + { + if ( RTC_JudgeLeapYear(years) ) + { + seccnt += 31622400u; /* The number of seconds in leap year is 31622400. */ + } + else + { + seccnt += 31536000u; /* The number of seconds in normal year is 31622400. */ + } + } + + /* Add up the seconds of the previous month. */ + init->Months -= 1u; /* The month count starts from 0 instead of 1, so current months - 1. */ + for (uint16_t months = 0u; months < init->Months; months++) + { + seccnt += (uint32_t)month_table[months] * 86400u; /* Calculate the number of seconds of months, the total number of seconds in a day is 86400. */ + if ( ( RTC_JudgeLeapYear(init->Years) ) && (months == 1u) ) /* The time is in a leap year and february, add the number of seconds in one day. */ + { + seccnt += 86400u; /* The number of seconds in day is 86400. */ + } + } + /* Add up the seconds of the previous date. */ + seccnt += (uint32_t)(init->Days - 1u) * 86400u; /* The day set for initialization is less than 24 hours, which needs to be subtracted by one day. */ + seccnt += (uint32_t)(init->Hours) * 3600u; /* There are 3600 seconds in a hour. */ + seccnt += (uint32_t)(init->Mins) * 60u; /* There are 60 seconds in a minute. */ + seccnt += (init->Secs); + + + while ( (0u == (RTC_GetStatus() & RTC_STATUS_OPERATION)) && (0u != (time->WaitTime--) ) ) /* Wait for write operation finish, only after the end of the previous write operation can new write be performed. */ + { + } + + /* Configrate counter value. */ + RTC_PutCounterData(seccnt); /* Put data into counter. */ + while ( ( 0u == (RTC_GetStatus() & RTC_STATUS_OPERATION) ) && (0u != (time->WaitTime--) ) ) /* Wait for write operation finish. */ + { + } + if (0u == time->WaitTime) /* Timeout. */ + { + return false; + } + + return true; +} + +/* Calculate and get current time. */ +void RTC_CalcTimeBlocking(RTC_Init_Type * init, RTC_Time_Type * time) +{ + while ( 0u == (RTC_GetStatus() & RTC_STATUS_SYNC) && (0u != time->WaitTime) ) /* Wait for register synchronization, only register synchronization can read RTC register. */ + { + time->WaitTime--; + } + uint32_t count = RTC_GetCounterData(); /* Get current seconds count. */ + + /* Calculated in days. */ + uint16_t years = init->LYears; + uint32_t days = count / 86400u; + + for (; days >= 365u; days -= 365u) + { + if ( RTC_JudgeLeapYear(years) ) /* Determine whether it is a leap year. */ + { + if (days >= 366u) + { + days -= 1u; + } + else + { + break; + } + } + years++; + } + init->Years = years; /* Get current years. */ + + uint16_t months = 0u; + for (; days >= 28u; days -= 28u) + { + if ( ( true == RTC_JudgeLeapYear(init->Years) ) && (months == 1u) ) /* The time is February of leap year. */ + { + if (days >= 29u) + { + days -= 1u; + } + else + { + break; + } + } + else + { + if (days >= month_table[months]) /* Reach the maximum number of days in the current month. */ + { + days = days - month_table[months] + 28u; + } + else + { + break; + } + } + months++; + } + init->Months = months + 1u; /* Get current months. */ + init->Days = days + 1u; /* Get current days. */ + init->Hours = ( count % 86400u) / 3600u; /* Get current hours. */ + init->Mins = ((count % 86400u) % 3600u) / 60u; /* Get current minutes. */ + init->Secs = ((count % 86400u) % 3600u) % 60u; /* Get current seconds. */ +} + +/* Setup the alarm response time. */ +bool RTC_SetAlarmBlocking(RTC_Time_Type * time) +{ + RTC_EnableInterrupts(RTC_INT_ALARM, true); /* Enable alarm interrupt. */ + while ( 0u == (RTC_GetStatus() & RTC_STATUS_SYNC) && (0u != time->WaitTime) ) /* Wait for register synchronization, only register synchronization can read RTC register. */ + { + time->WaitTime--; + } + uint32_t value = RTC_GetCounterData(); /* Get the current total number of seconds. */ + RTC_PutAlarmData(value + time->AlarmTime); /* Set alarm respond time. */ + while ( 0u == (RTC_GetStatus() & RTC_STATUS_OPERATION) && (0u != time->WaitTime) ) /* Wait for write operation finish. */ + { + time->WaitTime--; + } + if (0u == time->WaitTime) + { + return false; + } + return true; +} + +/* RTC interrupt request handler. */ +void RTC_TimeHandler(RTC_Init_Type * init, RTC_Time_Type * time, uint32_t interrupts) +{ + /* Seconds interrupt. */ + if ( ( 0u == (interrupts & RTC_INT_ALARM) ) && ( 1u == (interrupts & RTC_INT_SEC) ) ) + { + RTC_CalcTimeBlocking(init, time); /* Get current time. */ + if (time->SecDoneCallback) + { + (*(time->SecDoneCallback))((void *)time); /* Callback when seconds interrupt done. */ + } + } + + /* Alarm interrupt. */ + if (0u != (interrupts & RTC_INT_ALARM) ) /* When the alarm count value is the same as the current count value, the alarm clock interrupt is generated. */ + { + RTC_CalcTimeBlocking(init, time); /* Get current time. */ + RTC_ClearInterruptStatus(RTC_INT_ALARM); /* Clear alarm interrupt status flag. */ + if (time->AlarmDoneCallback) + { + (*(time->AlarmDoneCallback))((void *)time); /* Callback when alarm interrupt done. */ + } + } + RTC_ClearInterruptStatus(RTC_INT_SEC | RTC_INT_OVERFLOW); /* Clear seconds interrupt status flag and overflow status flag. */ +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_sdio.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_sdio.c new file mode 100644 index 0000000000..f7ba021dd2 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_sdio.c @@ -0,0 +1,319 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_sdio.h" + +static void SDIO_SetPeriphClockBaseClock(SDIO_Type * SDIOx, uint32_t busclk_hz, uint32_t periph_1mhz); + +void SDIO_Init(SDIO_Type * SDIOx, SDIO_Init_Type * init) +{ + SDIO_Enable(SDIOx, true); + + SDIOx->MMCCTRL = SDIO_MMCCTRL_OPMSEL(1) /* SD mode as default. */ + | SDIO_MMCCTRL_SELSM(1) /* hardware auto mode. */ + | SDIO_MMCCTRL_OUTM(0) /* open drain io mode. */ + | SDIO_MMCCTRL_CLKSP(init->ClkLineSpeedDiv) + | SDIO_MMCCTRL_SELPTSM(init->BaseClkSrc) + | SDIO_MMCCTRL_DATWT(0) /* use 1b data width as default. */ + | SDIO_MMCCTRL_MDEN(0) /* SD card as default. */ + | SDIO_MMCCTRL_INTEN(0) /* unlock the interrupt switchers. */ + | SDIO_MMCCTRL_RDWTEN(0) /* disable the read wait signal. */ + ; + + SDIOx->MMCCTRL |= SDIO_MMCCTRL_SELSM_MASK; + + if (init->BaseClkSrc == SDIO_BaseClkSrc_1MHz) + { + SDIO_SetPeriphClockBaseClock(SDIOx, init->BusClkHz, 1000000u); + } + + SDIO_SetDataBusWidth(SDIOx, SDIO_DataBusWidth_1b); + + SDIOx->MMCCRCCTL = 0u; /* disable all the crc feature. */ + SDIOx->MMCIOMBCTL = 0u; + SDIOx->MMCCRCCTL = SDIO_MMCCRCCTL_CMDCRCEN_MASK | SDIO_MMCCRCCTL_DATCRCEN_MASK; +} + +void SDIO_Enable(SDIO_Type * SDIOx, bool enable) +{ + if (enable) + { + SDIOx->MMCCARDSEL |= SDIO_MMCCARDSEL_CTREN_MASK /* enable the card controller. */ + | SDIO_MMCCARDSEL_ENPCLK_MASK /* enable the card clk. */ + ; + } + else + { + SDIOx->MMCCARDSEL &= ~(SDIO_MMCCARDSEL_CTREN_MASK | SDIO_MMCCARDSEL_ENPCLK_MASK); + } +} + +static void SDIO_SetPeriphClockBaseClock(SDIO_Type * SDIOx, uint32_t busclk_hz, uint32_t periph_1mhz) +{ + uint32_t div = busclk_hz / periph_1mhz / 2 - 1u; + + SDIOx->MMCCARDSEL = (SDIOx->MMCCARDSEL & ~SDIO_MMCCARDSEL_TSCALE_MASK) | SDIO_MMCCARDSEL_TSCALE(div); +} + +void SDIO_SetDataBusWidth(SDIO_Type *SDIOx, SDIO_DataBusWidth_Type width) +{ + if (width == SDIO_DataBusWidth_1b) + { + SDIOx->MMCCTRL &= ~SDIO_MMCCTRL_DATWT_MASK; + } + else if (width == SDIO_DataBusWidth_4b) + { + SDIOx->MMCCTRL |= SDIO_MMCCTRL_DATWT_MASK; + } +} + +/* return "SDIO_FLAG_XXXX." */ +uint32_t SDIO_GetStatus(SDIO_Type * SDIOx) +{ + uint32_t flags = SDIOx->CLRMMCINT; + + /* add the flags for data fifo. */ + if (SDIOx->BUFCTL & SDIO_BUFCTL_DBF_MASK) + { + flags |= SDIO_STATUS_DAT_BUF_FULL; + } + if (SDIOx->BUFCTL & SDIO_BUFCTL_DBE_MASK) + { + flags |= SDIO_STATUS_DAT_BUF_EMPTY; + } + + return flags; +} + +/* parameter flgas, refre to "SDIO_FLAG_XXXX." */ +void SDIO_ClearStatus(SDIO_Type * SDIOx, uint32_t flags) +{ + SDIOx->CLRMMCINT = (SDIO_STATUS_DAT0_BUSY - 1u) & flags; + + /* SDIO_STATUS_DAT_BUF_FULL and SDIO_STATUS_DAT_BUF_EMPYT would be cleared by hardware automatically. */ +} + +/* parameter interrupts, refre to "SDIO_INT_XXXX." */ +void SDIO_EnableInterrupts(SDIO_Type * SDIOx, uint32_t interrupts, bool enable) +{ + if (enable) + { + SDIOx->MMCINTMASK |= interrupts; + } + else + { + SDIOx->MMCINTMASK &= ~interrupts; + } + +} + +void SDIO_EnableFifoDMA(SDIO_Type * SDIOx, bool enable) +{ + uint32_t bufctl = SDIOx->BUFCTL & ~(SDIO_BUFCTL_DRM_MASK | SDIO_BUFCTL_DMAHEN_MASK); + + if (enable) + { + SDIOx->BUFCTL = bufctl | SDIO_BUFCTL_DMAHEN_MASK ; + } + else + { + SDIOx->BUFCTL = SDIOx->BUFCTL | SDIO_BUFCTL_DRM_MASK; + } +} + +/* parameter flgas, refre to "SDIO_CMD_FLAG_XXXX." */ +void SDIO_ExecuteCmd(SDIO_Type * SDIOx, uint8_t cmd_index, uint32_t param, uint32_t flags) +{ + /* setup parameter. */ + SDIOx->CMDBUF[4] = 0x40 | cmd_index; + SDIOx->CMDBUF[3] = ((param & 0xff000000) >> 24); + SDIOx->CMDBUF[2] = ((param & 0xff0000 ) >> 16); + SDIOx->CMDBUF[1] = ((param & 0xff00 ) >> 8); + SDIOx->CMDBUF[0] = ( param & 0xff ); + + /* prepare the command. */ + uint32_t cmd_io = SDIO_MMCIO_AUTOTR_MASK; + uint32_t cmd_io_ext = SDIOx->MMCIOMBCTL + & ~( SDIO_MMCIOMBCTL_SPMBDTR_MASK + | SDIO_MMCIOMBCTL_SMBDTD_MASK + | SDIO_MMCIOMBCTL_PAUTOTR_MASK ); + + if (0u != (flags & (SDIO_CMD_FLAG_READ_BLOCKS | SDIO_CMD_FLAG_READ_BLOCKS) ) ) + { + if (0u != (flags & SDIO_CMD_FLAG_READ_BLOCKS)) + { + cmd_io_ext |= SDIO_MMCIOMBCTL_SMBDTD_MASK; + } + + /* write MMCIO and MMCIOMBCTL to execute the cmd. */ + SDIOx->MMCIO = 0u; + SDIOx->MMCIOMBCTL = cmd_io_ext | SDIO_MMCIOMBCTL_SPMBDTR_MASK; + } + else + { + if (0u != (flags & SDIO_CMD_FLAG_READ_BLOCK) ) + { + cmd_io |= SDIO_MMCIO_TRANSFDIR_MASK; + } + if (0u != (flags & SDIO_CMD_FLAG_READ_CID_CSD) ) + { + cmd_io |= SDIO_MMCIO_CIDCSDRD_MASK; + } + //if (0u != (flags & SDIO_CMD_FLAG_FOLLOWED_DATA_BLOCK) ) + //{ + // cmd_io |= SDIO_MMCIO_CMDCH_MASK; + //} + //if (0u != (flags & SDIO_CMD_FLAG_STOP_TRAN) ) + //{ + // cmd_io |= SDIO_MMCIO_CMDAF_MASK; + //} + if (0u != (flags & SDIO_CMD_FLAG_ENABLE_DATA_XFER) ) + { + cmd_io |= SDIO_MMCIO_AUTODATTR_MASK; + } + SDIOx->MMCIOMBCTL = cmd_io_ext; + SDIOx->MMCIO = cmd_io; + } + + /* pending for the xfer done. */ + while ( 0u == (SDIO_STATUS_CMD_DONE & SDIO_GetStatus(SDIOx)) ) + {} + SDIO_ClearStatus(SDIOx, SDIO_STATUS_CMD_DONE); +} + +void SDIO_ExecuteData(SDIO_Type * SDIOx, uint32_t cmd_flags) +{ + uint32_t cmd_io_ext = SDIOx->MMCIOMBCTL + & ~( SDIO_MMCIOMBCTL_SPMBDTR_MASK + | SDIO_MMCIOMBCTL_SMBDTD_MASK + | SDIO_MMCIOMBCTL_PAUTOTR_MASK ); + uint32_t cmd_io = 0u; + + if (0u != (cmd_flags & SDIO_CMD_FLAG_WRITE_BLOCK) ) + { + //SDIOx->MMCIO = SDIO_MMCIO_AUTODATTR_MASK; + cmd_io |= SDIO_MMCIO_AUTODATTR_MASK; + } + if (0u != (cmd_flags & SDIO_CMD_FLAG_READ_BLOCK) ) + { + //SDIOx->MMCIO = SDIO_MMCIO_AUTODATTR_MASK | SDIO_MMCIO_TRANSFDIR_MASK; + cmd_io |= SDIO_MMCIO_AUTODATTR_MASK | SDIO_MMCIO_TRANSFDIR_MASK; + } + if (0u != (cmd_flags & SDIO_CMD_FLAG_WRITE_BLOCKS) ) + { + cmd_io_ext |= SDIO_MMCIOMBCTL_SPMBDTR_MASK; + //SDIOx->MMCIOMBCTL = cmd_io_ext; + } + else if (0u != (cmd_flags & SDIO_CMD_FLAG_READ_BLOCKS) ) + { + //SDIOx->MMCIO = SDIO_MMCIO_RESPCMDSEL_MASK | SDIO_MMCIO_AUTOTR_MASK; + //SDIOx->MMCIOMBCTL = cmd_io_ext | SDIO_MMCIOMBCTL_SPMBDTR_MASK | SDIO_MMCIOMBCTL_SMBDTD_MASK; + cmd_io_ext |= SDIO_MMCIOMBCTL_SPMBDTR_MASK | SDIO_MMCIOMBCTL_SMBDTD_MASK; + } + + SDIOx->MMCIO = cmd_io; + SDIOx->MMCIOMBCTL = cmd_io_ext; + +} + +void SDIO_RequestResp(SDIO_Type * SDIOx, SDIO_RespType_Type type, uint32_t *resp) +{ + uint32_t cmd_io = SDIO_MMCIO_AUTOTR_MASK | SDIO_MMCIO_RESPCMDSEL_MASK; + + if (type == SDIO_RespType_R2) + { + cmd_io |= SDIO_MMCIO_CIDCSDRD_MASK; + } + + SDIOx->MMCIO = cmd_io; + + /* pending for the xfer done. */ + while ( 0u == (SDIO_STATUS_CMD_DONE & SDIO_GetStatus(SDIOx)) ) + {} + SDIO_ClearStatus(SDIOx, SDIO_STATUS_CMD_DONE | SDIO_STATUS_CMD_CRC_ERR); + + + *resp = (SDIOx->CMDBUF[3] << 24) + | (SDIOx->CMDBUF[2] << 16) + | (SDIOx->CMDBUF[1] << 8 ) + | (SDIOx->CMDBUF[0]); + + if (type == SDIO_RespType_R2) + { + resp++; + *resp = (SDIOx->CMDBUF[7] << 24) + | (SDIOx->CMDBUF[6] << 16) + | (SDIOx->CMDBUF[5] << 8 ) + | (SDIOx->CMDBUF[4]); + resp++; + *resp = (SDIOx->CMDBUF[11] << 24) + | (SDIOx->CMDBUF[10] << 16) + | (SDIOx->CMDBUF[9 ] << 8 ) + | (SDIOx->CMDBUF[8 ]); + resp++; + *resp = (SDIOx->CMDBUF[15] << 24) + | (SDIOx->CMDBUF[14] << 16) + | (SDIOx->CMDBUF[13] << 8 ) + | (SDIOx->CMDBUF[12]); + } +} + +void SDIO_PutFifoData(SDIO_Type * SDIOx, uint32_t dat) +{ + SDIOx->DATABUF[0] = dat; +} + +uint32_t SDIO_GetFifoData(SDIO_Type * SDIOx) +{ + return SDIOx->DATABUF[0]; +} + +/* SDIO_BUFCTL_DBFEN bit would be cleared automatically by hardware. */ +void SDIO_ClearFifoData(SDIO_Type * SDIOx) +{ + SDIOx->BUFCTL |= SDIO_BUFCTL_DBFEN_MASK; +} + +/* the direction of fifo operation is read. need to switch to write before any write operation, + * and back to read mannually before the read operation. */ +void SDIO_SwitchFifoWrite(SDIO_Type * SDIOx, bool write) +{ + if (write) + { + SDIOx->BUFCTL |= SDIO_BUFCTL_SBAD_MASK; + } + else + { + SDIOx->BUFCTL &= ~SDIO_BUFCTL_SBAD_MASK; + } +} + +/* word_cnt is for 32-bit type. */ +void SDIO_SetFifoWatermark(SDIO_Type * SDIOx, uint32_t word_cnt) +{ + SDIOx->BUFCTL = (SDIOx->BUFCTL & ~SDIO_BUFCTL_DBML_MASK) | SDIO_BUFCTL_DBML(word_cnt); +} + +void SDIO_SetMultiBlockCount(SDIO_Type * SDIOx, uint32_t blk_cnt) +{ + SDIOx->MMCBLOCKCNT = blk_cnt; +} + +void SDIO_EnableFifoReadWait(SDIO_Type * SDIOx, bool enable) +{ + if (enable) + { + SDIOx->MMCCTRL |= SDIO_MMCCTRL_RDWTEN_MASK; + } + else + { + SDIOx->MMCCTRL &= ~SDIO_MMCCTRL_RDWTEN_MASK; + } +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_spi.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_spi.c new file mode 100644 index 0000000000..ac4d06a894 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_spi.c @@ -0,0 +1,177 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#include "hal_spi.h" + +void SPI_SetBaudrate(SPI_Type * SPIx, uint32_t src_clk, uint32_t baudrate) +{ + uint32_t div = src_clk / baudrate; + if (div < 2u) + { + /* div = 0, 1 is not allowed. */ + div = 2u; + } + SPIx->SPBRG = div; + if (div <= 4) + { + /* to support high speed mode. */ + SPIx->CCTL |= (SPI_I2S_CCTL_TXEDGE_MASK | SPI_I2S_CCTL_RXEDGE_MASK); + } + else + { + SPIx->CCTL &= ~(SPI_I2S_CCTL_TXEDGE_MASK | SPI_I2S_CCTL_RXEDGE_MASK); + } +} + +/* SPI peripheral is disabled just after the initialization. + * user needs to call SPI_Enable() before using the module. + */ +void SPI_InitMaster(SPI_Type * SPIx, SPI_Master_Init_Type * init) +{ + + /* Master. */ + SPIx->GCTL = SPI_I2S_GCTL_MODE_MASK; /* master mode, disable spi, and reset the other bits in CCTL. */ + + /* XferMode. */ + switch (init->XferMode) + { + case SPI_XferMode_RxOnly: + SPIx->GCTL |= SPI_I2S_GCTL_RXEN_MASK; + break; + + case SPI_XferMode_TxRx: + SPIx->GCTL |= (SPI_I2S_GCTL_RXEN_MASK | SPI_I2S_GCTL_TXEN_MASK); + break; + + default: + break; + } + + /* AutoCS. */ + if (init->AutoCS) + { + SPIx->GCTL |= SPI_I2S_GCTL_NSS_MASK; + } + else + { + SPIx->GCTL &= ~SPI_I2S_GCTL_NSS_MASK; + } + + /* Interrupts. Always enable the global interrupt. The specific events are controlled by each bits in INTEN register. */ + SPIx->GCTL |= SPI_I2S_GCTL_INTEN_MASK; + + /* BaudRate. */ + SPI_SetBaudrate(SPIx, init->ClockFreqHz, init->BaudRate); + + /* DataWidth. */ + if (init->DataWidth == SPI_DataWidth_8b) + { + SPIx->GCTL &= ~SPI_I2S_GCTL_DW832_MASK; + } + else + { + SPIx->GCTL |= SPI_I2S_GCTL_DW832_MASK; + SPIx->EXTCTL = SPI_I2S_EXTCTL_EXTLEN(init->DataWidth); + } + + /* CPOL & CPHA. */ + SPIx->CCTL = (SPIx->CCTL & ~(SPI_I2S_CCTL_CPHA_MASK | SPI_I2S_CCTL_CPOL_MASK)) + | ( (SPI_I2S_CCTL_CPHA_MASK | SPI_I2S_CCTL_CPOL_MASK) & ((init->PolarityPhase) << SPI_I2S_CCTL_CPHA_SHIFT) ); + + /* MSB. */ + if (init->LSB) + { + SPIx->CCTL |= SPI_I2S_CCTL_LSBFE_MASK; + } + else + { + SPIx->CCTL &= ~SPI_I2S_CCTL_LSBFE_MASK; + } +} + +void SPI_Enable(SPI_Type * SPIx, bool enable) +{ + if (enable) + { + SPIx->GCTL |= SPI_I2S_GCTL_SPIEN_MASK; + } + else + { + SPIx->GCTL &= ~SPI_I2S_GCTL_SPIEN_MASK; + } +} + +uint32_t SPI_GetStatus(SPI_Type * SPIx) +{ + return SPIx->CSTAT; +} + +void SPI_EnableInterrupts(SPI_Type * SPIx, uint32_t interrupts, bool enable) +{ + if (enable) + { + SPIx->INTEN |= interrupts; + } + else + { + SPIx->INTEN &= ~interrupts; + } +} + +uint32_t SPI_GetInterruptStatus(SPI_Type * SPIx) +{ + return SPIx->INTSTAT; +} + +void SPI_ClearInterruptStatus(SPI_Type * SPIx, uint32_t interrupts) +{ + SPIx->INTCLR = interrupts; +} + +void SPI_PutData(SPI_Type * SPIx, uint32_t dat) +{ + SPIx->TXREG = dat; +} + +uint32_t SPI_GetData(SPI_Type * SPIx) +{ + return SPIx->RXREG; +} + +void SPI_EnableDMA(SPI_Type * SPIx, bool enable) +{ + if (enable) + { + SPIx->GCTL |= SPI_I2S_GCTL_DMAMODE_MASK; + } + else + { + SPIx->GCTL &= ~SPI_I2S_GCTL_DMAMODE_MASK; + } +} + +uint32_t SPI_GetEnabledInterrupts(SPI_Type * SPIx) +{ + return SPIx->INTEN; +} + +uint32_t SPI_GetRxDataRegAddr(SPI_Type * SPIx) +{ + return (uint32_t)(&(SPIx->RXREG)); +} + +uint32_t SPI_GetTxDataRegAddr(SPI_Type * SPIx) +{ + return (uint32_t)(&(SPIx->TXREG)); +} + +void SPI_EnableCS(SPI_Type * SPIx, uint32_t cs_mask) +{ + SPIx->NSSR = ~(cs_mask); +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_syscfg.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_syscfg.c new file mode 100644 index 0000000000..67533707dd --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_syscfg.c @@ -0,0 +1,136 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#include "hal_syscfg.h" + +#define SYSCFG_EXTICR_MASK(x) ( (0x0Fu) << ( ( (uint32_t)(x) & 0x3u ) << 2u ) ) /* mask bit for clear exti line. */ +#define SYSCFG_EXTICR(x, y) ( (uint32_t)( (uint32_t)(x) << ( ( (uint32_t)(y) & 0x3u ) << 2u ) ) ) /* set the data for indicated exti port and line. */ + +void SYSCFG_SetBootMemMode(SYSCFG_BootMemMode_Type mode) +{ + SYSCFG->CFGR = ( SYSCFG->CFGR & ~ SYSCFG_CFGR_MEMMODE_MASK ) + | SYSCFG_CFGR_MEMMODE(mode); +} + +void SYSCFG_SetFSMCPinUseMode(SYSCFG_FSMCPinUseMode_Type mode) +{ + SYSCFG->CFGR = ( SYSCFG->CFGR & ~ SYSCFG_CFGR_FCODATAEN_MASK ) + | SYSCFG_CFGR_FCODATAEN(mode); +} + +void SYSCFG_SetFSMCMode(SYSCFG_FSMCMode_Type mode) +{ + SYSCFG->CFGR = ( SYSCFG->CFGR & ~ SYSCFG_CFGR_MODESEL_MASK ) + | SYSCFG_CFGR_MODESEL(mode); +} + +void SYSCFG_SetExtIntMux(SYSCFG_EXTIPort_Type port, SYSCFG_EXTILine_Type line) +{ + if ( line < SYSCFG_EXTILine_4) + { + SYSCFG->EXTICR1 = ( SYSCFG->EXTICR1 & ~ SYSCFG_EXTICR_MASK(line) ) + | ( SYSCFG_EXTICR(port, line) ); + } + else if ( line < SYSCFG_EXTILine_8 ) + { + SYSCFG->EXTICR2 = ( SYSCFG->EXTICR1 & ~ SYSCFG_EXTICR_MASK(line) ) + | ( SYSCFG_EXTICR(port, line) ); + } + else if ( line < SYSCFG_EXTILine_12 ) + { + SYSCFG->EXTICR3 = ( SYSCFG->EXTICR1 & ~ SYSCFG_EXTICR_MASK(line) ) + | ( SYSCFG_EXTICR(port, line) ); + } + else + { + SYSCFG->EXTICR4 = ( SYSCFG->EXTICR1 & ~ SYSCFG_EXTICR_MASK(line) ) + | ( SYSCFG_EXTICR(port, line) ); + } +} + +void SYSCFG_SetI2C0PortMode(SYSCFG_I2CPortMode_Type mode) +{ + SYSCFG->CFGR2 = ( SYSCFG->CFGR2 & ~ SYSCFG_CFGR2_I2C1MODESEL_MASK ) + | SYSCFG_CFGR2_I2C1MODESEL(mode); +} + +void SYSCFG_SetI2C1PortMode(SYSCFG_I2CPortMode_Type mode) +{ + SYSCFG->CFGR2 = ( SYSCFG->CFGR2 & ~ SYSCFG_CFGR2_I2C2MODESEL_MASK ) + | SYSCFG_CFGR2_I2C2MODESEL(mode); +} + +void SYSCFG_SetENETPortMode(SYSCFG_ENETPortMode_Type mode) +{ + SYSCFG->CFGR2 = ( SYSCFG->CFGR2 & ~ SYSCFG_CFGR2_MIIRMIISEL_MASK ) + | SYSCFG_CFGR2_MIIRMIISEL(mode); +} + +void SYSCFG_SetENETSpeedMode(SYSCFG_ENETSpeedMode_Type mode) +{ + SYSCFG->CFGR2 = ( SYSCFG->CFGR2 & ~ SYSCFG_CFGR2_MACSPDSEL_MASK ) + | SYSCFG_CFGR2_MACSPDSEL(mode); +} + +void SYSCFG_EnablePVD(SYSCFG_PVDConf_Type * conf) +{ + if (conf == NULL) + { + SYSCFG->PDETCSR &= ~ SYSCFG_PDETCSR_PVDE_MASK; + } + else + { + SYSCFG->PDETCSR = ( ( SYSCFG->PDETCSR & ~ ( SYSCFG_PDETCSR_PVDE_MASK + | SYSCFG_PDETCSR_PLS_MASK + | SYSCFG_PDETCSR_PVDO_MASK + ) ) + | SYSCFG_PDETCSR_PLS(conf->Thold) + | SYSCFG_PDETCSR_PVDO(conf->Output) + | SYSCFG_PDETCSR_PVDE_MASK + ); + + } +} + +void SYSCFG_EnableVDT(SYSCFG_VDTConf_Type * conf) +{ + if (conf == NULL) + { + SYSCFG->PDETCSR &= ~ SYSCFG_PDETCSR_VDTE_MASK; + } + else + { + SYSCFG->PDETCSR = ( ( SYSCFG->PDETCSR & ~ ( SYSCFG_PDETCSR_VDTE_MASK + | SYSCFG_PDETCSR_VDTLS_MASK + | SYSCFG_PDETCSR_VDTO_MASK + ) ) + | SYSCFG_PDETCSR_VDTLS(conf->Thold) + | SYSCFG_PDETCSR_VDTO(conf->Output) + | SYSCFG_PDETCSR_VDTE_MASK + ); + } +} + +void SYSCFG_EnableADCCheckVBatDiv3(bool enable) +{ + if (enable) + { + SYSCFG->PDETCSR |= SYSCFG_PDETCSR_VBATDIV3EN_MASK; + } + else + { + SYSCFG->PDETCSR &= ~ SYSCFG_PDETCSR_VBATDIV3EN_MASK; + } +} + +void SYSCFG_SetVOSDelayValue(uint32_t val) +{ + SYSCFG->VOSDLY = val; +} + +/* EOF. */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_16b.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_16b.c new file mode 100644 index 0000000000..4422c3a1c5 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_16b.c @@ -0,0 +1,302 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_tim_16b.h" + +bool TIM_16B_Init(TIM_16B_Type * TIMx, TIM_16B_Init_Type * init) +{ + uint32_t cr1 = TIMx->CR1 &~ ( TIM_16B_CR1_OPM_MASK + | TIM_16B_CR1_APRE_MASK + | TIM_16B_CR1_CMS_MASK + | TIM_16B_CR1_DIR_MASK + ); + cr1 |= TIM_16B_CR1_OPM(init->PeriodMode); + cr1 |= ((init->EnablePreloadPeriod) ? TIM_16B_CR1_APRE_MASK: 0u); + switch ( init->CountMode ) + { + case TIM_16B_CountMode_Increasing: + break; + case TIM_16B_CountMode_Decreasing: + cr1 |= TIM_16B_CR1_DIR_MASK; + break; + case TIM_16B_CountMode_CenterAligned1: + cr1 |= TIM_16B_CR1_CMS(1u); + break; + case TIM_16B_CountMode_CenterAligned2: + cr1 |= TIM_16B_CR1_CMS(2u); + break; + case TIM_16B_CountMode_CenterAligned3: + cr1 |= TIM_16B_CR1_CMS(3u); + break; + default: + break; + } + TIMx->CR1 = cr1; + /* Check the vadility of StepFreqHz. */ + if ( (init->StepFreqHz == 0u) || (init->StepFreqHz > init->ClockFreqHz) ) + { + return false; + } + /* Calculate the prescaler. */ + TIMx->PSC = init->ClockFreqHz / init->StepFreqHz - 1u; + TIMx->ARR = init->Period; + return true; +} + +void TIM_16B_Start(TIM_16B_Type * TIMx) +{ + TIMx->CR1 |= TIM_16B_CR1_CEN_MASK; +} + +void TIM_16B_Stop(TIM_16B_Type * TIMx) +{ + TIMx->CR1 &= ~TIM_16B_CR1_CEN_MASK; +} + +uint32_t TIM_16B_GetCounterValue(TIM_16B_Type * TIMx) +{ + return TIMx->CNT; +} + +void TIM_16B_ClearCounterValue(TIM_16B_Type * TIMx) +{ + TIMx->CNT = 0u; +} + +void TIM_16B_EnableInterrupts(TIM_16B_Type * TIMx, uint32_t interrupts, bool enable) +{ + if (enable) + { + TIMx->DIER |= interrupts; + } + else + { + TIMx->DIER &= ~interrupts; + } +} + +void TIM_16B_EnableDMA(TIM_16B_Type * TIMx, uint32_t dmas, bool enable) +{ + if (enable) + { + TIMx->DIER |= dmas; + } + else + { + TIMx->DIER &= ~dmas; + } +} + +void TIM_16B_DoSwTrigger(TIM_16B_Type * TIMx, uint32_t swtrgs) +{ + TIMx->EGR = swtrgs; +} + +uint32_t TIM_16B_GetInterruptStatus(TIM_16B_Type * TIMx) +{ + return TIMx->SR; +} + +void TIM_16B_ClearInterruptStatus(TIM_16B_Type * TIMx, uint32_t status) +{ + TIMx->SR &= ~status; +} + +/*******************************/ +static void _TIM_16B_WriteChannelCtrlReg(TIM_16B_Type * TIMx, uint32_t channel, uint32_t regval) +{ + switch (channel) + { + case TIM_16B_CHN_1: + TIMx->CCMR1 = (TIMx->CCMR1 & ~(0xFF)) | (regval & 0xFF); + break; + case TIM_16B_CHN_2: + TIMx->CCMR1 = (TIMx->CCMR1 & ~(0xFF00)) | ((regval & 0xFF) << 8u); + break; + case TIM_16B_CHN_3: + TIMx->CCMR2 = (TIMx->CCMR2 & ~(0xFF)) | (regval & 0xFF); + break; + case TIM_16B_CHN_4: + TIMx->CCMR2 = (TIMx->CCMR2 & ~(0xFF00)) | ((regval & 0xFF) << 8u); + break; + default: + break; + } +} + +void TIM_16B_EnableOutputCompare(TIM_16B_Type * TIMx, uint32_t channel, TIM_16B_OutputCompareConf_Type * conf) +{ + + uint32_t regval = TIM_16B_CCMR1_CC1S(TIM_16B_ChannelIOMode_Out) /* output compare mode. */ + | ( (conf->EnableFastOutput) ? TIM_16B_CCMR1_OC1FE_MASK : 0u ) /* fast output. */ + | ( (conf->EnablePreLoadChannelValue) ? TIM_16B_CCMR1_OC1PE_MASK : 0u) /* preload of channel value. */ + | TIM_16B_CCMR1_OC1M(conf->RefOutMode) /* output compare comparison mode. */ + | ( (conf->ClearRefOutOnExtTrigger) ? TIM_16B_CCMR1_OC1CE_MASK : 0u) /* external trigger clear ref. */ + ; + + _TIM_16B_WriteChannelCtrlReg(TIMx, channel, regval); + + TIM_16B_PutChannelValue(TIMx, channel, conf->ChannelValue); + + switch (conf->PinPolarity) + { + case TIM_16B_PinPolarity_Disable: + TIMx->CCER &= ~( TIM_16B_CCER_CC1E_MASK << (channel<<2u) ); + break; + + case TIM_16B_PinPolarity_Rising: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_16B_CCER_CC1E_MASK /* Enable the pin output / input. */ + ) << (channel<<2u)); + break; + + case TIM_16B_PinPolarity_Falling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_16B_CCER_CC1E_MASK /* Enable the pin output / input. */ + | TIM_16B_CCER_CC1P_MASK /* Set output active polarity. */ + | ~TIM_16B_CCER_CC1NP_MASK + ) << (channel<<2u)); + break; + + default: + break; + } +} + +void TIM_16B_EnableInputCapture(TIM_16B_Type * TIMx, uint32_t channel, TIM_16B_InputCaptureConf_Type * conf) +{ + uint32_t regval = TIM_16B_CCMR1_CC1S(TIM_16B_ChannelIOMode_In) /* input capture mode. */ + | TIM_16B_CCMR1_IC1PSC(conf->InDiv) + | TIM_16B_CCMR1_IC1F(conf->InFilter) + ; + + _TIM_16B_WriteChannelCtrlReg(TIMx, channel, regval); + + switch (conf->PinPolarity) + { + case TIM_16B_PinPolarity_Disable: + TIMx->CCER &= ~(TIM_16B_CCER_CC1E_MASK << (channel<<2u)); + break; + case TIM_16B_PinPolarity_Rising: + TIMx->CCER = (TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_16B_CCER_CC1E_MASK /* Enable the pin output / input */ + ) << (channel<<2u) ); + break; + case TIM_16B_PinPolarity_Falling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_16B_CCER_CC1E_MASK /* Enable the pin output / input */ + | TIM_16B_CCER_CC1P_MASK /* Set active input edge. */ + ) << (channel<<2u) ); + break; + case TIM_16B_PinPolarity_RisingOrFalling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_16B_CCER_CC1E_MASK /* Enable the pin output / input */ + | TIM_16B_CCER_CC1P_MASK /* Set active input edge. */ + | TIM_16B_CCER_CC1NP_MASK + ) << (channel<<2u) ); + break; + default: + break; + } +} + +uint16_t TIM_16B_GetChannelValue(TIM_16B_Type * TIMx, uint32_t channel) +{ + return TIMx->CCR[channel]; +} + +void TIM_16B_PutChannelValue(TIM_16B_Type * TIMx, uint32_t channel, uint16_t value) +{ + TIMx->CCR[channel] = value; +} + +void TIM_16B_EnableDeadArea(TIM_16B_Type * TIMx, TIM_16B_DeadAreaConf_Type * conf) +{ + TIMx->CR1 = ( TIMx->CR1 &~ TIM_16B_CR1_CKD_MASK ) + | ( TIM_16B_CR1_CKD(conf->StepFreqHz) ); /* set the frequncy ratio. */ +} + +void TIM_16B_EnableMasterMode(TIM_16B_Type * TIMx, TIM_16B_MasterModeConf_Type * conf) +{ + TIMx->CR2 = ( TIMx->CR2 &~ TIM_16B_CR2_MMS_MASK ) + | ( TIM_16B_CR2_MMS(conf->Out) ); /* Set master mode output. */ + + uint32_t smcr = TIMx->SMCR &~ TIM_16B_SMCR_MSM_MASK; + if (conf->EnableSync) /* synchronize with slave timers. */ + { + smcr |= TIM_16B_SMCR_MSM_MASK; + } + TIMx->SMCR = smcr; +} + +void TIM_16B_EnableSlaveMode(TIM_16B_Type * TIMx, TIM_16B_SlaveModeConf_Type * conf) +{ + if ( conf->Resp != TIM_16B_SlaveResp_Disable ) + { + TIMx->SMCR = ( TIMx->SMCR &~ ( TIM_16B_SMCR_TS_MASK + | TIM_16B_SMCR_SMS_MASK + ) ) + | TIM_16B_SMCR_TS(conf->In) /* set input trigger source. */ + | TIM_16B_SMCR_SMS(conf->Resp); /* set response to the source */ + } + else + { + TIMx->SMCR &= ~ TIM_16B_SMCR_SMS_MASK; + } +} + +void TIM_16B_EnableExtTriggerIn(TIM_16B_Type * TIMx, TIM_16B_ExtTriggerInConf_Type * conf) +{ + uint32_t smcr = TIMx->SMCR &~ ( TIM_16B_SMCR_ETPS_MASK + | TIM_16B_SMCR_ETF_MASK + | TIM_16B_SMCR_ECE_MASK + | TIM_16B_SMCR_ETP_MASK + ); + switch (conf->PinPolarity) + { + case TIM_16B_PinPolarity_Disable: + break; + case TIM_16B_PinPolarity_Rising: + smcr |= TIM_16B_SMCR_ECE_MASK; /* enable external trigger input. */ + break; + case TIM_16B_PinPolarity_Falling: + smcr |= TIM_16B_SMCR_ETP_MASK; /* falling edge active. */ + smcr |= TIM_16B_SMCR_ECE_MASK; /* enable external trigger input. */ + break; + default: + break; + } + smcr |= TIM_16B_SMCR_ETPS( conf->InDiv ); /* division to the input external trigger. */ + smcr |= TIM_16B_SMCR_ETF( conf->InFilter ); /* set filter. */ + TIMx->SMCR = smcr; +} + +uint32_t TIM_16B_EnableDMABurst(TIM_16B_Type * TIMx, TIM_16B_DMABurstConf_Type * conf) +{ + TIMx->DCR = TIM_16B_DCR_DBA(conf->BaseAddr) | TIM_16B_DCR_DBL(conf->Length); + return (uint32_t)(&(TIMx->DMAR)); +} + +TIM_16B_EncoderDirection_Type TIM_16B_GetEncoder(TIM_16B_Type * TIMx, uint32_t * value) +{ + if (value) + { + * value = TIM_16B_GetCounterValue(TIMx); + } + + if ( (TIMx->CR1 & TIM_16B_CR1_DIR_MASK) != 0u ) + { + return TIM_16B_EncoderDirection_Backward; + } + else + { + return TIM_16B_EncoderDirection_Forward; + } +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_32b.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_32b.c new file mode 100644 index 0000000000..ff84f642f7 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_32b.c @@ -0,0 +1,302 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_tim_32b.h" + +bool TIM_32B_Init(TIM_32B_Type * TIMx, TIM_32B_Init_Type * init) +{ + uint32_t cr1 = TIMx->CR1 &~ ( TIM_32B_CR1_OPM_MASK + | TIM_32B_CR1_APRE_MASK + | TIM_32B_CR1_CMS_MASK + | TIM_32B_CR1_DIR_MASK + ); + cr1 |= TIM_32B_CR1_OPM(init->PeriodMode); + cr1 |= ((init->EnablePreloadPeriod) ? TIM_32B_CR1_APRE_MASK: 0u); + switch ( init->CountMode ) + { + case TIM_32B_CountMode_Increasing: + break; + case TIM_32B_CountMode_Decreasing: + cr1 |= TIM_32B_CR1_DIR_MASK; + break; + case TIM_32B_CountMode_CenterAligned1: + cr1 |= TIM_32B_CR1_CMS(1u); + break; + case TIM_32B_CountMode_CenterAligned2: + cr1 |= TIM_32B_CR1_CMS(2u); + break; + case TIM_32B_CountMode_CenterAligned3: + cr1 |= TIM_32B_CR1_CMS(3u); + break; + default: + break; + } + TIMx->CR1 = cr1; + /* Check the vadility of StepFreqHz. */ + if ( (init->StepFreqHz == 0u) || (init->StepFreqHz > init->ClockFreqHz) ) + { + return false; + } + /* Calculate the prescaler. */ + TIMx->PSC = init->ClockFreqHz / init->StepFreqHz - 1u; + TIMx->ARR = init->Period; + return true; +} + +void TIM_32B_Start(TIM_32B_Type * TIMx) +{ + TIMx->CR1 |= TIM_32B_CR1_CEN_MASK; +} + +void TIM_32B_Stop(TIM_32B_Type * TIMx) +{ + TIMx->CR1 &= ~TIM_32B_CR1_CEN_MASK; +} + +uint32_t TIM_32B_GetCounterValue(TIM_32B_Type * TIMx) +{ + return TIMx->CNT; +} + +void TIM_32B_ClearCounterValue(TIM_32B_Type * TIMx) +{ + TIMx->CNT = 0u; +} + +void TIM_32B_EnableInterrupts(TIM_32B_Type * TIMx, uint32_t interrupts, bool enable) +{ + if (enable) + { + TIMx->DIER |= interrupts; + } + else + { + TIMx->DIER &= ~interrupts; + } +} + +void TIM_32B_EnableDMA(TIM_32B_Type * TIMx, uint32_t dmas, bool enable) +{ + if (enable) + { + TIMx->DIER |= dmas; + } + else + { + TIMx->DIER &= ~dmas; + } +} + +void TIM_32B_DoSwTrigger(TIM_32B_Type * TIMx, uint32_t swtrgs) +{ + TIMx->EGR = swtrgs; +} + +uint32_t TIM_32B_GetInterruptStatus(TIM_32B_Type * TIMx) +{ + return TIMx->SR; +} + +void TIM_32B_ClearInterruptStatus(TIM_32B_Type * TIMx, uint32_t status) +{ + TIMx->SR &= ~status; +} + +/*******************************/ +static void _TIM_32B_WriteChannelCtrlReg(TIM_32B_Type * TIMx, uint32_t channel, uint32_t regval) +{ + switch (channel) + { + case TIM_32B_CHN_1: + TIMx->CCMR1 = (TIMx->CCMR1 & ~(0xFF)) | (regval & 0xFF); + break; + case TIM_32B_CHN_2: + TIMx->CCMR1 = (TIMx->CCMR1 & ~(0xFF00)) | ((regval & 0xFF) << 8u); + break; + case TIM_32B_CHN_3: + TIMx->CCMR2 = (TIMx->CCMR2 & ~(0xFF)) | (regval & 0xFF); + break; + case TIM_32B_CHN_4: + TIMx->CCMR2 = (TIMx->CCMR2 & ~(0xFF00)) | ((regval & 0xFF) << 8u); + break; + default: + break; + } +} + +void TIM_32B_EnableOutputCompare(TIM_32B_Type * TIMx, uint32_t channel, TIM_32B_OutputCompareConf_Type * conf) +{ + + uint32_t regval = TIM_32B_CCMR1_CC1S(TIM_32B_ChannelIOMode_Out) /* output compare mode. */ + | ( (conf->EnableFastOutput) ? TIM_32B_CCMR1_OC1FE_MASK : 0u ) /* fast output. */ + | ( (conf->EnablePreLoadChannelValue) ? TIM_32B_CCMR1_OC1PE_MASK : 0u) /* preload of channel value. */ + | TIM_32B_CCMR1_OC1M(conf->RefOutMode) /* output compare comparison mode. */ + | ( (conf->ClearRefOutOnExtTrigger) ? TIM_32B_CCMR1_OC1CE_MASK : 0u) /* external trigger clear ref. */ + ; + + _TIM_32B_WriteChannelCtrlReg(TIMx, channel, regval); + + TIM_32B_PutChannelValue(TIMx, channel, conf->ChannelValue); + + switch (conf->PinPolarity) + { + case TIM_32B_PinPolarity_Disable: + TIMx->CCER &= ~( TIM_32B_CCER_CC1E_MASK << (channel<<2u) ); + break; + + case TIM_32B_PinPolarity_Rising: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_32B_CCER_CC1E_MASK /* Enable the pin output / input. */ + ) << (channel<<2u)); + break; + + case TIM_32B_PinPolarity_Falling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_32B_CCER_CC1E_MASK /* Enable the pin output / input. */ + | TIM_32B_CCER_CC1P_MASK /* Set output active polarity. */ + | ~TIM_32B_CCER_CC1NP_MASK + ) << (channel<<2u)); + break; + + default: + break; + } +} + +void TIM_32B_EnableInputCapture(TIM_32B_Type * TIMx, uint32_t channel, TIM_32B_InputCaptureConf_Type * conf) +{ + uint32_t regval = TIM_32B_CCMR1_CC1S(TIM_32B_ChannelIOMode_In) /* input capture mode. */ + | TIM_32B_CCMR1_IC1PSC(conf->InDiv) + | TIM_32B_CCMR1_IC1F(conf->InFilter) + ; + + _TIM_32B_WriteChannelCtrlReg(TIMx, channel, regval); + + switch (conf->PinPolarity) + { + case TIM_32B_PinPolarity_Disable: + TIMx->CCER &= ~(TIM_32B_CCER_CC1E_MASK << (channel<<2u)); + break; + case TIM_32B_PinPolarity_Rising: + TIMx->CCER = (TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_32B_CCER_CC1E_MASK /* Enable the pin output / input */ + ) << (channel<<2u) ); + break; + case TIM_32B_PinPolarity_Falling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_32B_CCER_CC1E_MASK /* Enable the pin output / input */ + | TIM_32B_CCER_CC1P_MASK /* Set active input edge. */ + ) << (channel<<2u) ); + break; + case TIM_32B_PinPolarity_RisingOrFalling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_32B_CCER_CC1E_MASK /* Enable the pin output / input */ + | TIM_32B_CCER_CC1P_MASK /* Set active input edge. */ + | TIM_32B_CCER_CC1NP_MASK + ) << (channel<<2u) ); + break; + default: + break; + } +} + +uint32_t TIM_32B_GetChannelValue(TIM_32B_Type * TIMx, uint32_t channel) +{ + return TIMx->CCR[channel]; +} + +void TIM_32B_PutChannelValue(TIM_32B_Type * TIMx, uint32_t channel, uint32_t value) +{ + TIMx->CCR[channel] = value; +} + +void TIM_32B_EnableDeadArea(TIM_32B_Type * TIMx, TIM_32B_DeadAreaConf_Type * conf) +{ + TIMx->CR1 = ( TIMx->CR1 &~ TIM_32B_CR1_CKD_MASK ) + | ( TIM_32B_CR1_CKD(conf->StepFreqHz) ); /* set the frequncy ratio. */ +} + +void TIM_32B_EnableMasterMode(TIM_32B_Type * TIMx, TIM_32B_MasterModeConf_Type * conf) +{ + TIMx->CR2 = ( TIMx->CR2 &~ TIM_32B_CR2_MMS_MASK ) + | ( TIM_32B_CR2_MMS(conf->Out) ); /* Set master mode output. */ + + uint32_t smcr = TIMx->SMCR &~ TIM_32B_SMCR_MSM_MASK; + if (conf->EnableSync) /* synchronize with slave timers. */ + { + smcr |= TIM_32B_SMCR_MSM_MASK; + } + TIMx->SMCR = smcr; +} + +void TIM_32B_EnableSlaveMode(TIM_32B_Type * TIMx, TIM_32B_SlaveModeConf_Type * conf) +{ + if ( conf->Resp != TIM_32B_SlaveResp_Disable ) + { + TIMx->SMCR = ( TIMx->SMCR &~ ( TIM_32B_SMCR_TS_MASK + | TIM_32B_SMCR_SMS_MASK + ) ) + | TIM_32B_SMCR_TS(conf->In) /* set input trigger source. */ + | TIM_32B_SMCR_SMS(conf->Resp); /* set response to the source */ + } + else + { + TIMx->SMCR &= ~ TIM_32B_SMCR_SMS_MASK; + } +} + +void TIM_32B_EnableExtTriggerIn(TIM_32B_Type * TIMx, TIM_32B_ExtTriggerInConf_Type * conf) +{ + uint32_t smcr = TIMx->SMCR &~ ( TIM_32B_SMCR_ETPS_MASK + | TIM_32B_SMCR_ETF_MASK + | TIM_32B_SMCR_ECE_MASK + | TIM_32B_SMCR_ETP_MASK + ); + switch (conf->PinPolarity) + { + case TIM_32B_PinPolarity_Disable: + break; + case TIM_32B_PinPolarity_Rising: + smcr |= TIM_32B_SMCR_ECE_MASK; /* enable external trigger input. */ + break; + case TIM_32B_PinPolarity_Falling: + smcr |= TIM_32B_SMCR_ETP_MASK; /* falling edge active. */ + smcr |= TIM_32B_SMCR_ECE_MASK; /* enable external trigger input. */ + break; + default: + break; + } + smcr |= TIM_32B_SMCR_ETPS( conf->InDiv ); /* division to the input external trigger. */ + smcr |= TIM_32B_SMCR_ETF( conf->InFilter ); /* set filter. */ + TIMx->SMCR = smcr; +} + +uint32_t TIM_32B_EnableDMABurst(TIM_32B_Type * TIMx, TIM_32B_DMABurstConf_Type * conf) +{ + TIMx->DCR = TIM_32B_DCR_DBA(conf->BaseAddr) | TIM_32B_DCR_DBL(conf->Length); + return (uint32_t)(&(TIMx->DMAR)); +} + +TIM_32B_EncoderDirection_Type TIM_32B_GetEncoder(TIM_32B_Type * TIMx, uint32_t * value) +{ + if (value) + { + * value = TIM_32B_GetCounterValue(TIMx); + } + + if ( (TIMx->CR1 & TIM_32B_CR1_DIR_MASK) != 0u ) + { + return TIM_32B_EncoderDirection_Backward; + } + else + { + return TIM_32B_EncoderDirection_Forward; + } +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_adv.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_adv.c new file mode 100644 index 0000000000..a6a8c88be5 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_adv.c @@ -0,0 +1,418 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_tim_adv.h" + +bool TIM_ADV_Init(TIM_ADV_Type * TIMx, TIM_ADV_Init_Type * init) +{ + uint32_t cr1 = TIMx->CR1 &~ ( TIM_ADV_CR1_OPM_MASK + | TIM_ADV_CR1_APRE_MASK + | TIM_ADV_CR1_CMS_MASK + | TIM_ADV_CR1_DIR_MASK + ); + cr1 |= TIM_ADV_CR1_OPM(init->PeriodMode); + cr1 |= ((init->EnablePreloadPeriod) ? TIM_ADV_CR1_APRE_MASK: 0u); + switch ( init->CountMode ) + { + case TIM_ADV_CountMode_Increasing: + break; + case TIM_ADV_CountMode_Decreasing: + cr1 |= TIM_ADV_CR1_DIR_MASK; + break; + case TIM_ADV_CountMode_CenterAligned1: + cr1 |= TIM_ADV_CR1_CMS(1u); + break; + case TIM_ADV_CountMode_CenterAligned2: + cr1 |= TIM_ADV_CR1_CMS(2u); + break; + case TIM_ADV_CountMode_CenterAligned3: + cr1 |= TIM_ADV_CR1_CMS(3u); + break; + default: + break; + } + TIMx->CR1 = cr1; + /* Check the vadility of StepFreqHz. */ + if ( (init->StepFreqHz == 0u) || (init->StepFreqHz > init->ClockFreqHz) ) + { + return false; + } + /* Calculate the prescaler. */ + TIMx->PSC = init->ClockFreqHz / init->StepFreqHz - 1u; + TIMx->ARR = init->Period; + return true; +} + +void TIM_ADV_Start(TIM_ADV_Type * TIMx) +{ + TIMx->CR1 |= TIM_ADV_CR1_CEN_MASK; +} + +void TIM_ADV_Stop(TIM_ADV_Type * TIMx) +{ + TIMx->CR1 &= ~TIM_ADV_CR1_CEN_MASK; +} + +uint32_t TIM_ADV_GetCounterValue(TIM_ADV_Type * TIMx) +{ + return TIMx->CNT; +} + +void TIM_ADV_ClearCounterValue(TIM_ADV_Type * TIMx) +{ + TIMx->CNT = 0u; +} + +void TIM_ADV_EnableInterrupts(TIM_ADV_Type * TIMx, uint32_t interrupts, bool enable) +{ + if (enable) + { + TIMx->DIER |= interrupts; + } + else + { + TIMx->DIER &= ~interrupts; + } +} + +void TIM_ADV_EnableDMA(TIM_ADV_Type * TIMx, uint32_t dmas, bool enable) +{ + if (enable) + { + TIMx->DIER |= dmas; + } + else + { + TIMx->DIER &= ~dmas; + } +} + +void TIM_ADV_DoSwTrigger(TIM_ADV_Type * TIMx, uint32_t swtrgs) +{ + TIMx->EGR = swtrgs; +} + +uint32_t TIM_ADV_GetInterruptStatus(TIM_ADV_Type * TIMx) +{ + return TIMx->SR; +} + +void TIM_ADV_ClearInterruptStatus(TIM_ADV_Type * TIMx, uint32_t status) +{ + TIMx->SR &= ~status; +} + +/*******************************/ +static void _TIM_ADV_WriteChannelCtrlReg(TIM_ADV_Type * TIMx, uint32_t channel, uint32_t regval) +{ + switch (channel) + { + case TIM_ADV_CHN_1: + TIMx->CCMR1 = (TIMx->CCMR1 & ~(0xFF)) | (regval & 0xFF); + break; + case TIM_ADV_CHN_2: + TIMx->CCMR1 = (TIMx->CCMR1 & ~(0xFF00)) | ((regval & 0xFF) << 8u); + break; + case TIM_ADV_CHN_3: + TIMx->CCMR2 = (TIMx->CCMR2 & ~(0xFF)) | (regval & 0xFF); + break; + case TIM_ADV_CHN_4: + TIMx->CCMR2 = (TIMx->CCMR2 & ~(0xFF00)) | ((regval & 0xFF) << 8u); + break; + default: + break; + } +} + +static void _TIM_ADV_EnableChannel5OutputCompare(TIM_ADV_Type * TIMx, TIM_ADV_OutputCompareConf_Type * conf) +{ + TIMx->CCMR3 = ( TIMx->CCMR3 & ~(0xFF) ) + | ( (conf->EnableFastOutput) ? TIM_ADV_CCMR3_OC5FE_MASK : 0u ) + | ( (conf->EnablePreLoadChannelValue) ? TIM_ADV_CCMR3_OC5PE_MASK : 0u ) + | TIM_ADV_CCMR3_OC5M(conf->RefOutMode); + TIM_ADV_PutChannelValue(TIMx, TIM_ADV_CHN_5, conf->ChannelValue); +} + +void TIM_ADV_EnableOutputCompare(TIM_ADV_Type * TIMx, uint32_t channel, TIM_ADV_OutputCompareConf_Type * conf) +{ + if ( channel == TIM_ADV_CHN_5) + { + _TIM_ADV_EnableChannel5OutputCompare(TIMx, conf); + } + else + { + uint32_t regval = TIM_ADV_CCMR1_CC1S(TIM_ADV_ChannelIOMode_Out) /* output compare mode. */ + | ( (conf->EnableFastOutput) ? TIM_ADV_CCMR1_OC1FE_MASK : 0u ) /* fast output. */ + | ( (conf->EnablePreLoadChannelValue) ? TIM_ADV_CCMR1_OC1PE_MASK : 0u) /* preload of channel value. */ + | TIM_ADV_CCMR1_OC1M(conf->RefOutMode) /* output compare comparison mode. */ + | ( (conf->ClearRefOutOnExtTrigger) ? TIM_ADV_CCMR1_OC1CE_MASK : 0u) /* external trigger clear ref. */ + ; + + _TIM_ADV_WriteChannelCtrlReg(TIMx, channel, regval); + + TIM_ADV_PutChannelValue(TIMx, channel, conf->ChannelValue); + + switch (conf->PinPolarity) + { + case TIM_ADV_PinPolarity_Disable: + TIMx->CCER &= ~( ( TIM_ADV_CCER_CC1E_MASK + | TIM_ADV_CCER_CC1NE_MASK + ) << (channel<<2u) ); /* Disable both channel. */ + break; + + case TIM_ADV_PinPolarity_Rising: + TIMx->CCER = ( ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | ( ( TIM_ADV_CCER_CC1E_MASK ) /* Enable the pin output / input. */ + | ( ( conf->COMPPinPolarity == TIM_ADV_PinPolarity_Falling) ? TIM_ADV_CCER_CC1NP_MASK : 0u ) + | ( ( conf->COMPPinPolarity != TIM_ADV_PinPolarity_Disable) ? TIM_ADV_CCER_CC1NE_MASK : 0u ) + ) << (channel<<2u)); + break; + + case TIM_ADV_PinPolarity_Falling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_ADV_CCER_CC1E_MASK /* Enable the pin output / input. */ + | TIM_ADV_CCER_CC1P_MASK /* Set output active polarity. */ + | ( ( conf->COMPPinPolarity == TIM_ADV_PinPolarity_Falling) ? TIM_ADV_CCER_CC1NP_MASK : 0u ) + | ( ( conf->COMPPinPolarity != TIM_ADV_PinPolarity_Disable) ? TIM_ADV_CCER_CC1NE_MASK : 0u ) + ) << (channel<<2u)); + break; + + default: + break; + } + } +} + +void TIM_ADV_EnableOutputCompareSwitch(TIM_ADV_Type * TIMx, bool enable) +{ + if (enable) + { + TIMx->BDTR |= TIM_ADV_BDTR_MOE_MASK; + } + else + { + TIMx->BDTR &= ~ TIM_ADV_BDTR_MOE_MASK; + } +} + +void TIM_ADV_EnableInputCapture(TIM_ADV_Type * TIMx, uint32_t channel, TIM_ADV_InputCaptureConf_Type * conf) +{ + uint32_t regval = TIM_ADV_CCMR1_CC1S(TIM_ADV_ChannelIOMode_In) /* input capture mode. */ + | TIM_ADV_CCMR1_IC1PSC(conf->InDiv) + | TIM_ADV_CCMR1_IC1F(conf->InFilter) + ; + + _TIM_ADV_WriteChannelCtrlReg(TIMx, channel, regval); + + switch (conf->PinPolarity) + { + case TIM_ADV_PinPolarity_Disable: + TIMx->CCER &= ~(TIM_ADV_CCER_CC1E_MASK << (channel<<2u)); + break; + case TIM_ADV_PinPolarity_Rising: + TIMx->CCER = (TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_ADV_CCER_CC1E_MASK /* Enable the pin output / input */ + ) << (channel<<2u) ); + break; + case TIM_ADV_PinPolarity_Falling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_ADV_CCER_CC1E_MASK /* Enable the pin output / input */ + | TIM_ADV_CCER_CC1P_MASK /* Set active input edge. */ + ) << (channel<<2u) ); + break; + case TIM_ADV_PinPolarity_RisingOrFalling: + TIMx->CCER = ( TIMx->CCER & ~(0xF << (channel<<2u)) ) + | (( TIM_ADV_CCER_CC1E_MASK /* Enable the pin output / input */ + | TIM_ADV_CCER_CC1P_MASK /* Set active input edge. */ + | TIM_ADV_CCER_CC1NP_MASK + ) << (channel<<2u) ); + break; + default: + break; + } +} + +uint16_t TIM_ADV_GetChannelValue(TIM_ADV_Type * TIMx, uint32_t channel) +{ + return TIMx->CCR[channel]; +} + +void TIM_ADV_PutChannelValue(TIM_ADV_Type * TIMx, uint32_t channel, uint16_t value) +{ + if ( channel == TIM_ADV_CHN_5 ) + { + TIMx->CCR5 = value; + } + else + { + TIMx->CCR[channel] = value; + } +} + +void TIM_ADV_EnableDeadArea(TIM_ADV_Type * TIMx, TIM_ADV_DeadAreaConf_Type * conf) +{ + TIMx->CR1 = ( TIMx->CR1 &~ TIM_ADV_CR1_CKD_MASK ) + | ( TIM_ADV_CR1_CKD(conf->StepFreqHz) ); /* set the frequncy ratio. */ + TIMx->BDTR = ( TIMx->BDTR &~ TIM_ADV_BDTR_DTG_MASK ) + | ( TIM_ADV_BDTR_DTG(conf->DeadAreaCoef) ); /* set the coefficient. */ +} + +void TIM_ADV_EnableMasterMode(TIM_ADV_Type * TIMx, TIM_ADV_MasterModeConf_Type * conf) +{ + TIMx->CR2 = ( TIMx->CR2 &~ TIM_ADV_CR2_MMS_MASK ) + | ( TIM_ADV_CR2_MMS(conf->Out) ); /* Set master mode output. */ + + uint32_t smcr = TIMx->SMCR &~ TIM_ADV_SMCR_MSM_MASK; + if (conf->EnableSync) /* synchronize with slave timers. */ + { + smcr |= TIM_ADV_SMCR_MSM_MASK; + } + TIMx->SMCR = smcr; +} + +void TIM_ADV_EnableSlaveMode(TIM_ADV_Type * TIMx, TIM_ADV_SlaveModeConf_Type * conf) +{ + if ( conf->Resp != TIM_ADV_SlaveResp_Disable ) + { + TIMx->SMCR = ( TIMx->SMCR &~ ( TIM_ADV_SMCR_TS_MASK + | TIM_ADV_SMCR_SMS_MASK + ) ) + | TIM_ADV_SMCR_TS(conf->In) /* set input trigger source. */ + | TIM_ADV_SMCR_SMS(conf->Resp); /* set response to the source */ + } + else + { + TIMx->SMCR &= ~ TIM_ADV_SMCR_SMS_MASK; + } +} + +void TIM_ADV_EnableExtTriggerIn(TIM_ADV_Type * TIMx, TIM_ADV_ExtTriggerInConf_Type * conf) +{ + uint32_t smcr = TIMx->SMCR &~ ( TIM_ADV_SMCR_ETPS_MASK + | TIM_ADV_SMCR_ETF_MASK + | TIM_ADV_SMCR_ECE_MASK + | TIM_ADV_SMCR_ETP_MASK + ); + switch (conf->PinPolarity) + { + case TIM_ADV_PinPolarity_Disable: + break; + case TIM_ADV_PinPolarity_Rising: + smcr |= TIM_ADV_SMCR_ECE_MASK; /* enable external trigger input. */ + break; + case TIM_ADV_PinPolarity_Falling: + smcr |= TIM_ADV_SMCR_ETP_MASK; /* falling edge active. */ + smcr |= TIM_ADV_SMCR_ECE_MASK; /* enable external trigger input. */ + break; + default: + break; + } + smcr |= TIM_ADV_SMCR_ETPS( conf->InDiv ); /* division to the input external trigger. */ + smcr |= TIM_ADV_SMCR_ETF( conf->InFilter ); /* set filter. */ + TIMx->SMCR = smcr; +} + +uint32_t TIM_ADV_EnableDMABurst(TIM_ADV_Type * TIMx, TIM_ADV_DMABurstConf_Type * conf) +{ + TIMx->DCR = TIM_ADV_DCR_DBA(conf->BaseAddr) | TIM_ADV_DCR_DBL(conf->Length); + return (uint32_t)(&(TIMx->DMAR)); +} + +TIM_ADV_EncoderDirection_Type TIM_ADV_GetEncoder(TIM_ADV_Type * TIMx, uint32_t * value) +{ + if (value) + { + * value = TIM_ADV_GetCounterValue(TIMx); + } + + if ( (TIMx->CR1 & TIM_ADV_CR1_DIR_MASK) != 0u ) + { + return TIM_ADV_EncoderDirection_Backward; + } + else + { + return TIM_ADV_EncoderDirection_Forward; + } +} + +void TIM_ADV_SetRepCounter(TIM_ADV_Type * TIMx, uint8_t value) +{ + TIMx->RCR = TIM_ADV_RCR_REP(value); +} + +uint8_t TIM_ADV_GetRepCounterValue(TIM_ADV_Type * TIMx) +{ + return TIMx->RCR >> TIM_ADV_RCR_REPCNT_SHIFT; +} + +void TIM_ADV_EnableIdleOut(TIM_ADV_Type * TIMx, uint32_t channel, TIM_ADV_IdleOut_Type * conf) +{ + uint32_t cr2 = TIMx->CR2 & ~ ( ( TIM_ADV_CR2_OIS1_MASK + | TIM_ADV_CR2_OIS1N_MASK + ) << ( channel << 1u ) + ); + if ( conf->PinPolarity == TIM_ADV_PinPolarity_Rising ) + { + cr2 |= ( TIM_ADV_CR2_OIS1_MASK << ( channel << 1u ) ); + } + if ( conf->COMPPinPolarity == TIM_ADV_PinPolarity_Rising ) + { + cr2 |= ( TIM_ADV_CR2_OIS1N_MASK << ( channel << 1u ) ); + } + TIMx->CR2 = cr2; +} + +void TIM_ADV_EnableLock(TIM_ADV_Type * TIMx, TIM_ADV_LockLevel_Type lock) +{ + TIMx->BDTR = ( TIMx->BDTR & ~ TIM_ADV_BDTR_LOCK_MASK ) + | TIM_ADV_BDTR_LOCK(lock); +} + +void TIM_ADV_EnableBreakIn(TIM_ADV_Type * TIMx, TIM_ADV_BreakIn_Type * conf) +{ + uint32_t bdtr = TIMx->BDTR &~ ( TIM_ADV_BDTR_BKE_MASK + | TIM_ADV_BDTR_BKP_MASK + | TIM_ADV_BDTR_AOE_MASK + | TIM_ADV_BDTR_DOE_MASK + ); + switch (conf->PinPolarity) + { + case TIM_ADV_PinPolarity_Disable: + break; + case TIM_ADV_PinPolarity_Rising: + bdtr |= ( TIM_ADV_BDTR_BKE_MASK + | TIM_ADV_BDTR_BKP_MASK + | ( conf->AutoSwitchOutput ? TIM_ADV_BDTR_AOE_MASK : 0u ) + | ( conf->DirectIdleOutput ? TIM_ADV_BDTR_DOE_MASK : 0u ) + ); + break; + case TIM_ADV_PinPolarity_Falling: + bdtr |= ( TIM_ADV_BDTR_BKE_MASK + | ( conf->AutoSwitchOutput ? TIM_ADV_BDTR_AOE_MASK : 0u ) + | ( conf->DirectIdleOutput ? TIM_ADV_BDTR_DOE_MASK : 0u ) + ); + break; + default: + break; + } +} + +void TIM_ADV_EnablePWMShift(TIM_ADV_Type * TIMx, uint32_t channel, uint16_t value) +{ + if ( value == TIM_ADV_GetChannelValue(TIMx, channel) ) + { + TIMx->PDER &= ~( TIM_ADV_PDER_CCR1SHIFTEN_MASK << channel ); + } + else + { + TIMx->PDER |= ( TIM_ADV_PDER_CCR1SHIFTEN_MASK << channel ); + TIMx->CCRFALL[channel] = value; + } +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_basic.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_basic.c new file mode 100644 index 0000000000..f02fc52b54 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_tim_basic.c @@ -0,0 +1,84 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_tim_basic.h" + +bool TIM_BASIC_Init(TIM_BASIC_Type * TIMx, TIM_BASIC_Init_Type * init) +{ + TIMx->CR1 = (TIMx->CR1 & ~(TIM_BASIC_CR1_OPM_MASK | TIM_BASIC_CR1_APRE_MASK) ) + | TIM_BASIC_CR1_OPM(init->PeriodMode) + | ((init->EnablePreloadPeriod) ? TIM_BASIC_CR1_APRE_MASK: 0u) + ; + + /* Check StepFreqHz validity. */ + if ( (init->StepFreqHz == 0u) || (init->StepFreqHz > init->ClockFreqHz) ) + { + return false; + } + /* Calculate prescaler of the timer.*/ + TIMx->PSC = init->ClockFreqHz / init->StepFreqHz - 1u; + /* Set the period length. */ + TIMx->ARR = init->Period; + return true; +} + +void TIM_BASIC_Start(TIM_BASIC_Type * TIMx) +{ + TIMx->CR1 |= TIM_BASIC_CR1_CEN_MASK; +} + +void TIM_BASIC_Stop(TIM_BASIC_Type * TIMx) +{ + TIMx->CR1 &= ~TIM_BASIC_CR1_CEN_MASK; +} + +uint32_t TIM_BASIC_GetCounterValue(TIM_BASIC_Type * TIMx) +{ + return TIMx->CNT; +} + +void TIM_BASIC_EnableInterrupts(TIM_BASIC_Type *TIMx, uint32_t interrupts, bool enable) +{ + if (enable) + { + TIMx->DIER |= interrupts; + } + else + { + TIMx->DIER &= ~interrupts; + } +} + +void TIM_BASIC_EnableDMA(TIM_BASIC_Type *TIMx, uint32_t dmas, bool enable) +{ + if (enable) + { + TIMx->DIER |= dmas; + } + else + { + TIMx->DIER &= ~dmas; + } +} + +void TIM_BASIC_DoSwTrigger(TIM_BASIC_Type *TIMx, uint32_t swtrgs) +{ + TIMx->EGR = swtrgs; +} + +uint32_t TIM_BASIC_GetInterruptStatus(TIM_BASIC_Type * TIMx) +{ + return TIMx->SR; +} + +void TIM_BASIC_ClearInterruptStatus(TIM_BASIC_Type *TIMx, uint32_t status) +{ + TIMx->SR &= ~status; +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_uart.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_uart.c new file mode 100644 index 0000000000..98ad86de24 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_uart.c @@ -0,0 +1,130 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_uart.h" + +void UART_Init(UART_Type * UARTx, UART_Init_Type * init) +{ + uint32_t ccr = UARTx->CCR & ~( UART_CCR_PEN_MASK + | UART_CCR_PSEL_MASK + | UART_CCR_SPB0_MASK + | UART_CCR_CHAR_MASK + | UART_CCR_SPB1_MASK + ); + /* WordLength. */ + ccr |= UART_CCR_CHAR(init->WordLength); + + /* StopBits. */ + if ( (init->StopBits == UART_StopBits_2) || (init->StopBits == UART_StopBits_1_5) ) + { + ccr |= UART_CCR_SPB0_MASK; + } + if ( (init->StopBits == UART_StopBits_0_5) || (init->StopBits == UART_StopBits_1_5) ) + { + ccr |= UART_CCR_SPB1_MASK; + } + + /* Parity. */ + if (init->Parity == UART_Parity_Even) + { + ccr |= UART_CCR_PEN_MASK; + } + if (init->Parity == UART_Parity_Odd) + { + ccr |= UART_CCR_PEN_MASK | UART_CCR_PSEL_MASK; + } + UARTx->CCR = ccr; + + /* XferMode. */ + uint32_t gcr = UARTx->GCR & ~( UART_GCR_RXEN_MASK + | UART_GCR_TXEN_MASK + | UART_GCR_AUTOFLOWEN_MASK + ); + gcr |= ((uint32_t)(init->XferMode) << UART_GCR_RXEN_SHIFT); + if (init->HwFlowControl == UART_HwFlowControl_RTS_CTS) + { + gcr |= UART_GCR_AUTOFLOWEN_MASK; + } + UARTx->GCR = gcr; + + /* Setup the baudrate. */ + UARTx->BRR = (init->ClockFreqHz / init->BaudRate) / 16u; + UARTx->FRA = (init->ClockFreqHz / init->BaudRate) % 16u; +} + +void UART_Enable(UART_Type * UARTx, bool enable) +{ + if (enable) + { + UARTx->GCR |= UART_GCR_UARTEN_MASK; + } + else + { + UARTx->GCR &= ~UART_GCR_UARTEN_MASK; + } +} + +void UART_EnableInterrupts(UART_Type * UARTx, uint32_t interrupts, bool enable) +{ + (enable) ? (UARTx->IER |= interrupts) : (UARTx->IER &= ~interrupts); +} + +uint32_t UART_GetEnabledInterrupts(UART_Type * UARTx) +{ + return UARTx->IER; +} + +void UART_EnableDMA(UART_Type * UARTx, bool enable) +{ + if (enable) + { + UARTx->GCR |= UART_GCR_DMAMODE_MASK; + } + else + { + UARTx->GCR &= ~UART_GCR_DMAMODE_MASK; + } +} + +void UART_PutData(UART_Type * UARTx, uint8_t value) +{ + UARTx->TDR = value; +} + +uint8_t UART_GetData(UART_Type * UARTx) +{ + return (uint8_t)(UARTx->RDR & 0xFFU); +} + +/* return flags */ +uint32_t UART_GetStatus(UART_Type * UARTx) +{ + return UARTx->CSR; +} + +/* return flags. */ +uint32_t UART_GetInterruptStatus(UART_Type * UARTx) +{ + return UARTx->ISR; +} + +void UART_ClearInterruptStatus(UART_Type * UARTx, uint32_t interrupts) +{ + UARTx->ICR = interrupts; +} + +uint32_t UART_GetRxDataRegAddr(UART_Type * UARTx) +{ + return (uint32_t)(&(UARTx->RDR)); +} + +uint32_t UART_GetTxDataRegAddr(UART_Type * UARTx) +{ + return (uint32_t)(&(UARTx->TDR)); +} + +/* EOF. */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_usb.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_usb.c new file mode 100644 index 0000000000..f34f982979 --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_usb.c @@ -0,0 +1,313 @@ +/* + * Copyright 2021 MindMotion Microelectronics Co., Ltd. + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "hal_usb.h" + + +void USB_SetBufDespTableAddr(USB_Type * USBx, uint32_t addr) +{ + USBx->BDTPAGE01 = USB_BDTPAGE01_BDTBA(addr >> 9u); + USBx->BDTPAGE02 = USB_BDTPAGE02_BDTBA(addr >> 16u); + USBx->BDTPAGE03 = USB_BDTPAGE03_BDTBA(addr >> 24u); +} + +void USB_InitDevice(USB_Type * USBx, USB_Device_Init_Type *init) +{ + if ( (uintptr_t)(init->BufDespTable_Addr) % 512u != 0u) + { + return; + } + USB_SetDeviceAddr(USBx, 0x00u); + USB_SetBufDespTableAddr(USBx, init->BufDespTable_Addr); + USB_Enable(USBx, true); +} + +void USB_EnableInterrupts(USB_Type * USBx, uint32_t interrupts, bool enable) +{ + if(enable) + { + USBx->INTENB |= interrupts; + } + else + { + USBx->INTENB &= ~interrupts; + } +} + +uint32_t USB_GetEnabledInterrupts(USB_Type * USBx) +{ + return USBx->INTENB; +} + +uint32_t USB_GetInterruptStatus(USB_Type * USBx) +{ + uint32_t stat = USBx->INTSTAT; + uint32_t enb = USBx->INTENB; + return stat & enb; +} + +void USB_ClearInterruptStatus(USB_Type * USBx, uint32_t interrupts) +{ + uint32_t enb = USBx->INTENB; + USBx->INTSTAT = interrupts & enb; +} + +void USB_EnableErrInterrupts(USB_Type * USBx, uint32_t interrupts, bool enable) +{ + if(enable) + { + USBx->ERRENB |= interrupts; + } + else + { + USBx->ERRENB &= ~interrupts; + } +} + + +uint32_t USB_GetEnabledErrInterrupts(USB_Type * USBx) +{ + return USBx->ERRENB; +} + +uint32_t USB_GetErrInterruptStatus(USB_Type * USBx) +{ + uint32_t stat = USBx->ERRSTAT; + uint32_t enb = USBx->ERRENB; + USBx->ERRSTAT = stat & ~enb; + return stat & enb; +} + +void USB_ClearErrInterruptStatus(USB_Type * USBx, uint32_t interrupts) +{ + uint32_t enb = USBx->ERRENB; + USBx->ERRSTAT = interrupts & enb; +} + +uint32_t USB_GetBufDespIndex(USB_Type * USBx) +{ + return (USBx->STAT)>>2; +} + +void USB_Enable(USB_Type * USBx, bool enable) +{ + if(enable) + { + USBx->CTL |= USB_CTL_USBEN_MASK; + } + else + { + USBx->CTL &= ~USB_CTL_USBEN_MASK; + } +} + +void USB_EnableOddEvenReset(USB_Type * USBx, bool enable) +{ + if(enable) + { + USBx->CTL |= USB_CTL_ODDRST_MASK; + } + else + { + USBx->CTL &= ~USB_CTL_ODDRST_MASK; + } +} + +void USB_EnableResumeSignal(USB_Type * USBx, bool enable) +{ + if(enable) + { + USBx->CTL |= USB_CTL_RESUME_MASK; + } + else + { + USBx->CTL &= ~USB_CTL_RESUME_MASK; + } +} + +void USB_EnableSuspend(USB_Type * USBx, bool enable) +{ + if(true == enable) + { + USBx->CTL |= USB_CTL_TXDSUSPENDTOKENBUSY_MASK; + } + else + { + USBx->CTL &= ~USB_CTL_TXDSUSPENDTOKENBUSY_MASK; + } + +} + + +void USB_SetDeviceAddr(USB_Type * USBx, uint8_t addr) +{ + USBx->ADDR = ( (USBx->ADDR & ~USB_ADDR_ADDR_MASK) + | (addr & USB_ADDR_ADDR_MASK) ) + ; +} + +uint8_t USB_GetDeviceAddr(USB_Type * USBx) +{ + return USBx->ADDR & USB_ADDR_ADDR_MASK; +} + +uint32_t USB_GetBufDespTableAddr(USB_Type * USBx) +{ + return (uint32_t) + ( ( (USBx->BDTPAGE01 >> USB_BDTPAGE01_BDTBA_SHIFT) << 9u ) + | ( (USBx->BDTPAGE02 >> USB_BDTPAGE02_BDTBA_SHIFT) << 16u) + | ( (USBx->BDTPAGE03 >> USB_BDTPAGE03_BDTBA_SHIFT) << 24u) + ); +} + +uint32_t USB_GetFrameNumber(USB_Type * USBx) +{ + return (USBx->FRMNUML) | (USBx->FRMNUML << 7u); +} + +USB_BufDesp_Type * USB_GetBufDesp(USB_Type * USBx) +{ + USB_BufDespTable_Type *bdt = (USB_BufDespTable_Type *)USB_GetBufDespTableAddr(USBx); + return &bdt->Index[USBx->STAT >> 2]; +} + +USB_TokenPid_Type USB_BufDesp_GetTokenPid(USB_BufDesp_Type * bd) +{ + return (USB_TokenPid_Type)bd->TOK_PID; +} + +uint32_t USB_BufDesp_GetPacketAddr(USB_BufDesp_Type * bd) +{ + return bd->ADDR; +} + +uint32_t USB_BufDesp_GetPacketSize(USB_BufDesp_Type * bd) +{ + return bd->BC; +} + +void USB_BufDesp_Reset(USB_BufDesp_Type * bd) +{ + bd->BDT_STALL = 0u; + bd->NINC = 0u; + bd->KEEP = 0u; + bd->DTS = 1u; +} + +uint32_t USB_GetEndPointIndex(USB_Type * USBx) +{ + return (USBx->STAT & USB_STAT_ENDP_MASK) >> USB_STAT_ENDP_SHIFT; +} + +USB_Direction_Type USB_GetXferDirection(USB_Type * USBx) +{ + return (USB_Direction_Type)( (USBx->STAT & USB_STAT_TX_MASK) >> USB_STAT_TX_SHIFT); +} + +USB_BufDesp_OddEven_Type USB_GetBufDespOddEven(USB_Type * USBx) +{ + return (USB_BufDesp_OddEven_Type)( (USBx->STAT & USB_STAT_ODD_MASK) >> USB_STAT_ODD_SHIFT ); +} + +bool USB_BufDesp_Xfer(USB_BufDesp_Type * bd, uint32_t data_n, uint8_t * buffer, uint32_t len) +{ + if (1u == bd->OWN) + { + return false; + } + bd->ADDR = (uint32_t)buffer; + bd->DATA = data_n; + bd->BC = len; + bd->OWN = 1u; + return true; +} + +bool USB_BufDesp_IsBusy(USB_BufDesp_Type * bd) +{ + if (1u == bd->OWN) + { + return true; + } + else + { + return false; + } +} + +void USB_EnableEndPoint(USB_Type * USBx, uint32_t index, USB_EndPointMode_Type mode, bool enable) +{ + if (false == enable) + { + USBx->EPCTL[index] = 0u; + USB_BufDespTable_Type * bdt = (USB_BufDespTable_Type * )USB_GetBufDespTableAddr(USBx); + bdt->Table[index][0u][0u].HEAD = 0u; + bdt->Table[index][0u][1u].HEAD = 0u; + bdt->Table[index][1u][0u].HEAD = 0u; + bdt->Table[index][1u][1u].HEAD = 0u; + return; + } + if (USB_EndPointMode_Control == mode) + { + USBx->EPCTL[index] |= USB_EPCTL_EPCTLDISEPRXENEPTXEN(3) | USB_EPCTL_EPHSHK_MASK; + } + else if (USB_EndPointMode_Bulk == mode) + { + USBx->EPCTL[index] |= USB_EPCTL_EPCTLDISEPRXENEPTXEN(7u) | USB_EPCTL_EPHSHK_MASK; + } + else if (USB_EndPointMode_Interrupt == mode) + { + USBx->EPCTL[index] |= USB_EPCTL_EPCTLDISEPRXENEPTXEN(7u) | USB_EPCTL_EPHSHK_MASK; + } + else if (USB_EndPointMode_Isochronous == mode) + { + USBx->EPCTL[index] |= USB_EPCTL_EPCTLDISEPRXENEPTXEN(7u); + } +} + +void USB_EnableEndPointStall(USB_Type * USBx, uint32_t index, bool enable) +{ + USB_BufDespTable_Type * bdt = (USB_BufDespTable_Type * )USB_GetBufDespTableAddr(USBx); + for (uint32_t i = 0; i < USB_BDT_EP_NUM; i++) + { + if (true == enable) + { + USBx->EPCTL[i] |= USB_EPCTL_EPSTALL_MASK; + bdt->Table[i][USB_BufDesp_OddEven_Odd ][USB_Direction_IN ].BDT_STALL = 1u; + bdt->Table[i][USB_BufDesp_OddEven_Odd ][USB_Direction_OUT].BDT_STALL = 1u; + bdt->Table[i][USB_BufDesp_OddEven_Even][USB_Direction_IN ].BDT_STALL = 1u; + bdt->Table[i][USB_BufDesp_OddEven_Even][USB_Direction_OUT].BDT_STALL = 1u; + } + else + { + USBx->EPCTL[i] &= ~USB_EPCTL_EPSTALL_MASK; + bdt->Table[i][USB_BufDesp_OddEven_Odd ][USB_Direction_IN ].BDT_STALL = 0u; + bdt->Table[i][USB_BufDesp_OddEven_Odd ][USB_Direction_IN ].OWN = 0u; + bdt->Table[i][USB_BufDesp_OddEven_Odd ][USB_Direction_OUT].BDT_STALL = 0u; + bdt->Table[i][USB_BufDesp_OddEven_Odd ][USB_Direction_OUT].OWN = 0u; + bdt->Table[i][USB_BufDesp_OddEven_Even][USB_Direction_IN ].BDT_STALL = 0u; + bdt->Table[i][USB_BufDesp_OddEven_Even][USB_Direction_IN ].OWN = 0u; + bdt->Table[i][USB_BufDesp_OddEven_Even][USB_Direction_OUT].BDT_STALL = 0u; + bdt->Table[i][USB_BufDesp_OddEven_Even][USB_Direction_OUT].OWN = 0u; + } + } +} + +uint32_t USB_GetEnabledEndPointStall(USB_Type * USBx) +{ + uint32_t status = 0u; + for(uint32_t i = 0u; i < USB_BDT_EP_NUM; i++) + { + if (0 != (USBx->EPCTL[i] & USB_EPCTL_EPSTALL_MASK) ) + { + status |= 1u << i; + } + } + return status; +} + +/* EOF. */ + diff --git a/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_wwdg.c b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_wwdg.c new file mode 100644 index 0000000000..dfa069ef8c --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/MM32F3270_HAL_Driver/Src/hal_wwdg.c @@ -0,0 +1,50 @@ +/* hal_wwdg.h */ +#include "hal_wwdg.h" + +void WWDG_Init(WWDG_Type * WWDGx, WWDG_Init_Type * init) +{ + if (NULL != init) + { + WWDGx->CFGR = WWDG_CFGR_WDGTB(init->Prescaler) + | WWDG_CFGR_W(init->UpperLimit); + } +} + +void WWDG_Start(WWDG_Type * WWDGx) +{ + WWDGx->CR |= WWDG_CR_WDGA_MASK; +} + +void WWDG_Reload(WWDG_Type * WWDGx, uint32_t value) +{ + if (value > WWDG_LOWER_LIMIT) + { + WWDGx->CR = (WWDGx->CR & ~WWDG_CR_T_MASK) | WWDG_CR_T(value); + } +} + +void WWDG_EnableInterrupts(WWDG_Type * WWDGx, uint32_t interrupts, bool enable) +{ + if ( (true == enable) && (WWDG_INT_ALMOST_TIMEOUT == interrupts) ) + { + WWDGx->CFGR |= WWDG_CFGR_EWI_MASK; + } + else + { + /* if WWDG_INT_ALMOST_TIMEOUT interrupt is enabled, only MCU reset can close it. */ + } +} + + +uint32_t WWDG_GetStatus(WWDG_Type * WWDGx) +{ + return WWDGx->SR; +} + +void WWDG_ClearStatus(WWDG_Type * WWDGx, uint32_t status) +{ + WWDGx->SR &= ~status; +} + + +/* EOF. */ diff --git a/bsp/mm32/libraries/MM32F3270_HAL/SConscript b/bsp/mm32/libraries/MM32F3270_HAL/SConscript new file mode 100644 index 0000000000..438b21e89d --- /dev/null +++ b/bsp/mm32/libraries/MM32F3270_HAL/SConscript @@ -0,0 +1,67 @@ +import rtconfig +Import('RTT_ROOT') +from building import * + +# get current directory +cwd = GetCurrentDir() + +# The set of source files associated with this SConscript file. +src = Split(""" +CMSIS/Device/MM32/MM32F3277/Source/Templates/system_mm32f3277g.c +MM32F3270_HAL_Driver/Src/hal_rcc.c +MM32F3270_HAL_Driver/Src/hal_dma.c +MM32F3270_HAL_Driver/Src/hal_gpio.c +""") + +if GetDepend(['RT_USING_PIN']): + src += ['MM32F3270_HAL_Driver/Src/hal_exti.c'] + src += ['MM32F3270_HAL_Driver/Src/hal_syscfg.c'] + +if GetDepend(['RT_USING_SERIAL']): + src += ['MM32F3270_HAL_Driver/Src/hal_uart.c'] + +if GetDepend(['RT_USING_I2C']): + src += ['MM32F3270_HAL_Driver/Src/hal_i2c.c'] + +if GetDepend(['RT_USING_SPI']): + src += ['MM32F3270_HAL_Driver/Src/hal_spi.c'] + +if GetDepend(['RT_USING_USB']): + src += ['MM32F3270_HAL_Driver/Src/hal_usb.c'] + +if GetDepend(['RT_USING_HWTIMER']) or GetDepend(['RT_USING_PWM']): + src += ['MM32F3270_HAL_Driver/Src/hal_tim_16b.c'] + src += ['MM32F3270_HAL_Driver/Src/hal_tim_32b.c'] + src += ['MM32F3270_HAL_Driver/Src/hal_tim_adv.c'] + src += ['MM32F3270_HAL_Driver/Src/hal_tim_basic.c'] + +if GetDepend(['RT_USING_ADC']): + src += ['MM32F3270_HAL_Driver/Src/hal_adc.c'] + src += ['MM32F3270_HAL_Driver/Src/hal_comp.c'] + +if GetDepend(['RT_USING_DAC']): + src += ['MM32F3270_HAL_Driver/Src/hal_dac.c'] + +if GetDepend(['RT_USING_RTC']): + src += ['MM32F3270_HAL_Driver/Src/hal_rtc.c'] + +if GetDepend(['RT_USING_EXRAM']): + src += ['MM32F3270_HAL_Driver/Src/hal_fsmc.c'] + +if GetDepend(['RT_USING_SDIO']): + src += ['MM32F3270_HAL_Driver/Src/hal_sdio.c'] + +if GetDepend(['RT_USING_WDT']): + src += ['MM32F3270_HAL_Driver/Src/hal_iwdg.c'] + src += ['MM32F3270_HAL_Driver/Src/hal_wwdg.c'] + +path = [cwd + '/CMSIS/Device/MM32/MM32F3277/Include', + cwd + '/MM32F3270_HAL_Driver/Inc'] + +if not GetDepend('PKG_CMSIS_CORE'): + path += [cwd + '/CMSIS/Include'] + +CPPDEFINES = ['USE_HAL_DRIVER'] +group = DefineGroup('Libraries', src, depend = [''], CPPPATH = path, CPPDEFINES = CPPDEFINES) + +Return('group') diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/Kconfig b/bsp/mm32/mm32f3270-100ask-pitaya/Kconfig new file mode 100644 index 0000000000..7a400db91f --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/Kconfig @@ -0,0 +1,22 @@ +mainmenu "RT-Thread Configuration" + +config BSP_DIR + string + option env="BSP_ROOT" + default "." + +config RTT_DIR + string + option env="RTT_ROOT" + default "../../.." + +config PKGS_DIR + string + option env="PKGS_ROOT" + default "packages" + +source "$RTT_DIR/Kconfig" +source "$PKGS_DIR/Kconfig" +source "../libraries/Kconfig" +source "board/Kconfig" + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/README.md b/bsp/mm32/mm32f3270-100ask-pitaya/README.md new file mode 100644 index 0000000000..0e243983f0 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/README.md @@ -0,0 +1,108 @@ +# 百问网PitayaLite开发板BSP说明 + +## 简介 + +本文档是为百问网PitayaLite开发板提供的BSP(板级支持包)说明。 + +主要内容如下： + +* 开发板资源介绍 + +* BSP快速上手 + +* 进阶使用方法 + +通过阅读快速上手章节开发者可以快速的上手该BSP，将RT-Thread运行在开发板上。在进阶使用指南章节，将会介绍更多高级功能，帮助开发者利用RT-Thread驱动更多板载资源。 + +## 开发板介绍 + +PitayaLite开发板是百问网推出的一块基于ARM Cortex-M3内核的开发板，最高主频为120MHz，该开发板具有丰富的板载资源，可以较好地发挥MM32F3277G8P这块处理器的性能。 + +开发板外观如下图所示： +![board](figures/board.png) + +该开发板常用**板载资源**如下： + +* MCU: MM32F3273G8P，主频120MHz，512KB FLASH，128KB RAM +* 常用外设： + * 按键：1个，KEY（兼具唤醒功能，PA0） + * LED：1，蓝灯（PA1） +* 常用接口：USB转串口 +* 调试接口：DAP + +## 外设支持 + +本BSP目前对外设的支持情况如下： + +| 板载外设 | 支持情况 | 备注 | +| -------- |:--------:| ------------------------------------- | +| USB转串口 | 支持 | UART1 | +| 用户LED | 支持 | 蓝灯（PA1） | +| 用户按键 | 支持 | KEY(PA0) | +| **片上外设** | **支持情况** | **备注** | +| GPIO | 支持 | PA0, PA1... PK15 ---> PIN: 0, 1...176 | +| UART | 支持 | UART1/2/3 | + +## 使用说明 + +使用说明分为如下两个章节： + +- 快速上手 + + 本章节是为刚接触 RT-Thread 的新手准备的使用说明，遵循简单的步骤即可将 RT-Thread 操作系统运行在该开发板上，看到实验效果 。 + +- 进阶使用 + + 本章节是为需要在 RT-Thread 操作系统上使用更多开发板资源的开发者准备的。通过使用 ENV 工具对 BSP 进行配置，可以开启更多板载资源，实现更多高级功能。 + +### 快速上手 + +本 BSP 为开发者提供 MDK5 和 IAR 工程，并且支持 GCC 开发环境。下面以 MDK5 开发环境为例，介绍如何将系统运行起来。 + +#### 硬件连接 + +使用数据线将开发板的DAP和USB转串口和PC连接起来。 + +#### 编译下载 + +双击 project.uvprojx 文件，打开 MDK5 工程，编译并下载程序到开发板。 + +> 工程默认配置使用 CMSIS-DAP 下载程序，在通过 CMSIS-DAP连接开发板的基础上，点击下载按钮即可下载程序到开发板 + +#### 运行结果 + +下载程序成功之后，系统会自动运行，观察开发板上 LED 的运行效果，其中一个 LED 会周期性闪烁。 + +连接开发板对应串口到 PC , 在终端工具里打开相应的串口（115200-8-1-N），复位设备后，可以看到 RT-Thread 的输出信息: + +```bash + \ | / +- RT - Thread Operating System + / | \ 5.0.0 build Aug 31 2022 14:22:43 + 2006 - 2022 Copyright by RT-Thread team +msh /> +``` + +### 进阶使用 + +此 BSP 默认只开启了 GPIO 和 串口1 的功能，如果需使用 ADC、Flash 等更多高级功能，需要利用 ENV 工具对BSP 进行配置，步骤如下： + +1. 在 bsp 下打开 env 工具。 + +2. 输入`menuconfig`命令配置工程，配置好之后保存退出。 + +3. 输入`pkgs --update`命令更新软件包。 + +4. 输入`scons --target=mdk5/iar` 命令重新生成工程。 + +本章节更多详细的介绍请参考 [STM32 系列 BSP 外设驱动使用教程](../docs/STM32系列BSP外设驱动使用教程.md)。 + +## 注意事项 + +暂无 + +## 联系人信息 + +维护人: + +* 100ask-Alen, 邮箱:<3062056224@qq.com> \ No newline at end of file diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/SConscript b/bsp/mm32/mm32f3270-100ask-pitaya/SConscript new file mode 100644 index 0000000000..20f7689c53 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/SConscript @@ -0,0 +1,15 @@ +# for module compiling +import os +Import('RTT_ROOT') +from building import * + +cwd = GetCurrentDir() +objs = [] +list = os.listdir(cwd) + +for d in list: + path = os.path.join(cwd, d) + if os.path.isfile(os.path.join(path, 'SConscript')): + objs = objs + SConscript(os.path.join(d, 'SConscript')) + +Return('objs') diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/SConstruct b/bsp/mm32/mm32f3270-100ask-pitaya/SConstruct new file mode 100644 index 0000000000..01bcd4d2e4 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/SConstruct @@ -0,0 +1,60 @@ +import os +import sys +import rtconfig + +if os.getenv('RTT_ROOT'): + RTT_ROOT = os.getenv('RTT_ROOT') +else: + RTT_ROOT = os.path.normpath(os.getcwd() + '/../../..') + +sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')] +try: + from building import * +except: + print('Cannot found RT-Thread root directory, please check RTT_ROOT') + print(RTT_ROOT) + exit(-1) + +TARGET = 'rt-thread.' + rtconfig.TARGET_EXT + +DefaultEnvironment(tools=[]) +env = Environment(tools = ['mingw'], + AS = rtconfig.AS, ASFLAGS = rtconfig.AFLAGS, + CC = rtconfig.CC, CFLAGS = rtconfig.CFLAGS, + AR = rtconfig.AR, ARFLAGS = '-rc', + CXX = rtconfig.CXX, CXXFLAGS = rtconfig.CXXFLAGS, + LINK = rtconfig.LINK, LINKFLAGS = rtconfig.LFLAGS) +env.PrependENVPath('PATH', rtconfig.EXEC_PATH) + +if rtconfig.PLATFORM == 'iar': + env.Replace(CCCOM = ['$CC $CFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -o $TARGET $SOURCES']) + env.Replace(ARFLAGS = ['']) + env.Replace(LINKCOM = env["LINKCOM"] + ' --map rt-thread.map') + +Export('RTT_ROOT') +Export('rtconfig') + +SDK_ROOT = os.path.abspath('./') + +if os.path.exists(SDK_ROOT + '/libraries'): + libraries_path_prefix = SDK_ROOT + '/libraries' +else: + libraries_path_prefix = os.path.dirname(SDK_ROOT) + '/libraries' + +SDK_LIB = libraries_path_prefix +Export('SDK_LIB') + +# prepare building environment +objs = PrepareBuilding(env, RTT_ROOT, has_libcpu=False) + +mm32_library = 'MM32F3270_HAL' +rtconfig.BSP_LIBRARY_TYPE = mm32_library + +# include libraries +objs.extend(SConscript(os.path.join(libraries_path_prefix, mm32_library, 'SConscript'))) + +# include drivers +objs.extend(SConscript(os.path.join(libraries_path_prefix, 'HAL_Drivers', 'SConscript'))) + +# make a building +DoBuilding(TARGET, objs) diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/applications/SConscript b/bsp/mm32/mm32f3270-100ask-pitaya/applications/SConscript new file mode 100644 index 0000000000..9bb9abae89 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/applications/SConscript @@ -0,0 +1,15 @@ +from building import * +import os + +cwd = GetCurrentDir() +src = Glob('*.c') +CPPPATH = [cwd] + +group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH) + +list = os.listdir(cwd) +for item in list: + if os.path.isfile(os.path.join(cwd, item, 'SConscript')): + group = group + SConscript(os.path.join(item, 'SConscript')) + +Return('group') diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/applications/main.c b/bsp/mm32/mm32f3270-100ask-pitaya/applications/main.c new file mode 100644 index 0000000000..4cb1dc6693 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/applications/main.c @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#include +#include +#include +#include + +/* defined the LED0 pin: PA1 */ +#define LED0_PIN GET_PIN(A, 1) + +int main(void) +{ + /* set LED0 pin mode to output */ + rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT); + + while (1) + { + rt_pin_write(LED0_PIN, PIN_HIGH); + rt_thread_mdelay(500); + rt_pin_write(LED0_PIN, PIN_LOW); + rt_thread_mdelay(500); + } +} diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/Kconfig b/bsp/mm32/mm32f3270-100ask-pitaya/board/Kconfig new file mode 100644 index 0000000000..f38455cdc1 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/Kconfig @@ -0,0 +1,60 @@ +menu "Hardware Drivers Config" + +config SOC_MM32F3277 + bool + select SOC_SERIES_MM32F3277 + select RT_USING_COMPONENTS_INIT + select RT_USING_USER_MAIN + default y + +menu "Onboard Peripheral Drivers" + + config BSP_USING_USB_TO_USART + bool "Enable USB TO USART (uart1)" + select BSP_USING_UART + select BSP_USING_UART1 + default y + + config BSP_USING_USER_LED + bool "Enable User LED (pa1)" + select RT_USING_PIN + default y + + config BSP_USING_USER_KEY + bool "Enable User Key (pa0)" + select RT_USING_PIN + default y +endmenu + +menu "On-chip Peripheral Drivers" + + config BSP_USING_GPIO + bool "Enable GPIO" + select RT_USING_PIN + default y + + menuconfig BSP_USING_UART + bool "Enable UART" + default y + select RT_USING_SERIAL + if BSP_USING_UART + config BSP_USING_UART1 + bool "Enable UART1" + default y + config BSP_USING_UART2 + bool "Enable UART2" + default n + config BSP_USING_UART3 + bool "Enable UART3" + default n + endif + + source "../libraries/HAL_Drivers/Kconfig" + +endmenu + +menu "Board extended module Drivers" + +endmenu + +endmenu diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/SConscript b/bsp/mm32/mm32f3270-100ask-pitaya/board/SConscript new file mode 100644 index 0000000000..81b2bbaa1f --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/SConscript @@ -0,0 +1,33 @@ +import os +import rtconfig +from building import * + +Import('SDK_LIB') + +cwd = GetCurrentDir() + +# add general drivers +src = Split(''' +board.c +mm32f3277g8p_msp.c +''') + +if GetDepend(['BSP_USING_USER_KEY']): + src += Glob("ports/user_key.c") + +path = [cwd] +path += [cwd + '/ports'] + +startup_path_prefix = SDK_LIB + +if rtconfig.PLATFORM == 'gcc': + src += [startup_path_prefix + '/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/gcc/startup_mm32f3270.s'] +elif rtconfig.PLATFORM in ['armcc', 'armclang']: + src += [startup_path_prefix + '/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/arm/startup_mm32f3270.s'] +elif rtconfig.CROSS_TOOL == 'iar': + src += [startup_path_prefix + '/MM32F3270_HAL/CMSIS/Device/MM32/MM32F3277/Source/Templates/iar/startup_mm32f3270.s'] + +# You can select chips from the list above +CPPDEFINES = ['MM32F3277G'] +group = DefineGroup('Drivers', src, depend = [''], CPPPATH = path, CPPDEFINES = CPPDEFINES) +Return('group') diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/board.c b/bsp/mm32/mm32f3270-100ask-pitaya/board/board.c new file mode 100644 index 0000000000..183a26e2ca --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/board.c @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#include "board.h" +#include "hal_rcc.h" + +static uint32_t SystemClockFreq = HSI_VALUE; +static uint32_t AHBClockFreq = HSI_VALUE; +static uint32_t APB1ClockFreq = HSI_VALUE; +static uint32_t APB2ClockFreq = HSI_VALUE; + +static void update_systemclock(void); +static void update_ahb_clock(void); +static void update_apb1_clock(void); +static void update_apb2_clock(void); + +void SystemClock_Config(void) +{ + /* 使能总线外设时钟 */ + RCC->AHB1ENR |= (1u << 13u); // 使能FLASH外设 + FLASH->ACR |= (4<<0); // 设置Flash的等待周期 + + /* 使能PWR/DBG */ + RCC->APB1ENR |= (1<<28); + PWR->CR1 &= ~(2<<14); + PWR->CR1 |= (2<<14); // 如果系统时钟需要达到最大频率 120MHz，需要将 VOS 设置为 2’b10 即 1.7V + + RCC->CR &= ~((1<<16) | (1<<24) ); // 关闭HSE/PLL + + /* 配置HSE和PLL */ + RCC->CR |= (1<<16); // 使能HSE + while(0 == ((RCC->CR)&(1<<17)));// 等待HSE稳定 + + RCC->PLLCFGR |= (1<<0); // 配置PLL的时钟源HSE + RCC->PLLCFGR &= ~(1<<1); // 配置PLL的时钟源HSE不分频后再作为时钟输入源 + RCC->PLLCFGR &= ~(0x7F<<16); + RCC->PLLCFGR |= (19<<16); // 配置PLL的倍频系数:20倍 -> 12MHz/2*20 = 120MHz + RCC->PLLCFGR &= ~(0x7<<8); + RCC->PLLCFGR |= (1<<8); // 配置PLL的分频系数:2 + + RCC->CR |= (1<<24); // 使能PLL + while(0 == (RCC->CR & (1<<25)));// 等待PLL时钟稳定 + + /* 配置系统时钟、AHB、APB时钟 */ + RCC->CFGR |= (0<<4); // AHB不分频 + RCC->CFGR |= (4<<8); // APB1 2分频 + RCC->CFGR |= (4<<11); // APB2 2分频 + RCC->CFGR |= (2<<22); // PLL输出时钟3分频后输出给USB：120MHz/3=40MHz + RCC->CFGR |= (7<<24); // PLL输出时钟2分频后输出到MCO + RCC->CFGR |= (2<<0); // 选择PLL输出用作系统时钟 + while(0 == (RCC->CFGR & (2<<2))); // 等待PLL输出用作系统时钟稳定 + + update_systemclock(); + update_ahb_clock(); + update_apb1_clock(); + update_apb2_clock(); +} + +static void update_systemclock(void) +{ + uint32_t tmpreg = 0U, prediv = 0U, pllclk = 0U, pllmul = 0U; + uint32_t sysclockfreq = HSI_VALUE; + + tmpreg = RCC->CFGR; + /* 获取系统时钟源 */ + switch(tmpreg & RCC_CFGR_SWS_MASK) + { + case RCC_SYSCLKSOURCE_STATUS_HSI: + { + sysclockfreq = HSI_VALUE; + break; + } + case RCC_SYSCLKSOURCE_STATUS_HSE: + { + sysclockfreq = HSE_VALUE; + break; + } + case RCC_SYSCLKSOURCE_STATUS_LSI: + { + sysclockfreq = LSI_VALUE; + break; + } + case RCC_SYSCLKSOURCE_STATUS_PLLCLK: + { + /* 获取PLL的输入时钟源 */ + if(RCC->PLLCFGR&0x01) // HSE用作PLL的输入时钟 + { + if(RCC->PLLCFGR&0x02) // HSE二分频后输入给PLL + { + pllclk = HSE_VALUE>>1; + } + else // HSE部分变频直接输出给PLL + { + pllclk = HSE_VALUE; + } + } + else // HSI用作PLL的输入时钟 + { + pllclk = HSI_VALUE; + } + prediv = (RCC->PLLCFGR>>8)&0x07; // PLL的分频系数：PLLCFGR[10:8] + pllmul = (RCC->PLLCFGR>>16)&0x7F; // PLL的倍频系数: PLLCFGR[22:16] + sysclockfreq = pllclk * (pllmul+1) / (prediv+1); + + break; + } + default:break; + } + + SystemClockFreq = sysclockfreq; +} + +static void update_ahb_clock(void) +{ + uint32_t tmpreg = RCC->CFGR; + uint8_t hpre = (tmpreg>>4)&0x0F; + if((hpre&0x08) == 0) // 不分频 + AHBClockFreq = SystemClockFreq; + else + { + hpre = (hpre&0x07) + 1; + AHBClockFreq = SystemClockFreq>>hpre; + } +} + +static void update_apb1_clock(void) +{ + uint32_t tmpreg = RCC->CFGR; + uint8_t ppre1 = (tmpreg>>8)&0x0F; + if((ppre1&0x04) == 0) // 不分频 + APB1ClockFreq = AHBClockFreq; + else + { + ppre1 = (ppre1&0x03) + 1; + APB1ClockFreq = AHBClockFreq>>ppre1; + } +} + +static void update_apb2_clock(void) +{ + uint32_t tmpreg = RCC->CFGR; + uint8_t ppre2 = (tmpreg>>11)&0x0F; + if((ppre2&0x04) == 0) // 不分频 + APB2ClockFreq = AHBClockFreq; + else + { + ppre2 = (ppre2&0x03) + 1; + APB2ClockFreq = AHBClockFreq>>ppre2; + } +} + +uint32_t HAL_GetSysClockFreq(void) +{ + return SystemClockFreq; +} + +uint32_t HAL_Get_AHB_Clock(void) +{ + return AHBClockFreq; +} + +uint32_t HAL_Get_APB1_Clock(void) +{ + return APB1ClockFreq; +} + +uint32_t HAL_Get_APB2_Clock(void) +{ + return APB2ClockFreq; +} + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/board.h b/bsp/mm32/mm32f3270-100ask-pitaya/board/board.h new file mode 100644 index 0000000000..fa381b2549 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/board.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#ifndef __BOARD_H__ +#define __BOARD_H__ + +#include +#include "drv_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MM32_FLASH_START_ADRESS ((uint32_t)0x08000000) +#define MM32_FLASH_SIZE (512 * 1024) +#define MM32_FLASH_END_ADDRESS ((uint32_t)(MM32_FLASH_START_ADRESS + MM32_FLASH_SIZE)) + +/* Internal SRAM memory size[Kbytes] <8-128>, Default: 128*/ +#define MM32_SRAM_SIZE 128 +#define MM32_SRAM_END (0x20000000 + MM32_SRAM_SIZE * 1024) + +#if defined(__ARMCC_VERSION) +extern int Image$$RW_IRAM1$$ZI$$Limit; +#define HEAP_BEGIN ((void *)&Image$$RW_IRAM1$$ZI$$Limit) +#elif __ICCARM__ +#pragma section="CSTACK" +#define HEAP_BEGIN (__segment_end("CSTACK")) +#else +extern int __bss_end; +#define HEAP_BEGIN ((void *)&__bss_end) +#endif + +#define HEAP_END MM32_SRAM_END + +#define LSI_VALUE (40000) +#define HSI_VALUE (8000000) +#define HSE_VALUE (12000000) + +#define __USE_HSE (0) +#define __USE_HSE_PLL (1) +#define __USE_HSI_PLL (0) + +#define RCC_CFGR_SWS_Pos (2U) +#define RCC_CFGR_SWS_Msk (0x3UL << RCC_CFGR_SWS_Pos) /*!< 0x0000000C */ + +#define RCC_CFGR_SWS_HSI 0x00000000U /*!< HSI oscillator used as system clock */ +#define RCC_CFGR_SWS_HSE 0x00000004U /*!< HSE oscillator used as system clock */ +#define RCC_CFGR_SWS_PLL 0x00000008U /*!< PLL used as system clock */ +#define RCC_CFGR_SWS_LSI 0x0000000CU /*!< LSI used as system clock */ + +#define RCC_SYSCLKSOURCE_STATUS_HSI RCC_CFGR_SWS_HSI /*!< HSI used as system clock */ +#define RCC_SYSCLKSOURCE_STATUS_HSE RCC_CFGR_SWS_HSE /*!< HSE used as system clock */ +#define RCC_SYSCLKSOURCE_STATUS_PLLCLK RCC_CFGR_SWS_PLL /*!< PLL used as system clock */ +#define RCC_SYSCLKSOURCE_STATUS_LSI RCC_CFGR_SWS_LSI /*!< LSI used as system clock */ + +uint32_t HAL_GetSysClockFreq(void); +uint32_t HAL_Get_AHB_Clock(void); +uint32_t HAL_Get_APB1_Clock(void); +uint32_t HAL_Get_APB2_Clock(void); +void SystemClock_Config(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __BOARD_H__ */ diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.icf b/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.icf new file mode 100644 index 0000000000..92ab6c7b93 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.icf @@ -0,0 +1,30 @@ +/*###ICF### Section handled by ICF editor, don't touch! ****/ +/*-Editor annotation file-*/ +/* IcfEditorFile="$TOOLKIT_DIR$\config\ide\IcfEditor\cortex_v1_0.xml" */ +/*-Specials-*/ +define symbol __ICFEDIT_intvec_start__ = 0x08000000; +/*-Memory Regions-*/ +define symbol __ICFEDIT_region_ROM_start__ = 0x08000000; +define symbol __ICFEDIT_region_ROM_end__ = 0x0807FFFF; +define symbol __ICFEDIT_region_RAM_start__ = 0x20000000; +define symbol __ICFEDIT_region_RAM_end__ = 0x2001FFFF; +/*-Sizes-*/ +define symbol __ICFEDIT_size_cstack__ = 0x800; +define symbol __ICFEDIT_size_heap__ = 0x800; +/**** End of ICF editor section. ###ICF###*/ + +define memory mem with size = 4G; +define region ROM_region = mem:[from __ICFEDIT_region_ROM_start__ to __ICFEDIT_region_ROM_end__]; +define region RAM_region = mem:[from __ICFEDIT_region_RAM_start__ to __ICFEDIT_region_RAM_end__]; + +define block CSTACK with alignment = 8, size = __ICFEDIT_size_cstack__ { }; +define block HEAP with alignment = 8, size = __ICFEDIT_size_heap__ { }; + +initialize by copy { readwrite }; +do not initialize { section .noinit }; + +place at address mem:__ICFEDIT_intvec_start__ { readonly section .intvec }; + +place in ROM_region { readonly }; +place in RAM_region { readwrite, + block CSTACK, block HEAP }; \ No newline at end of file diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.ld b/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.ld new file mode 100644 index 0000000000..1fc009995a --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.ld @@ -0,0 +1,208 @@ +/* +** ################################################################### +** Processors: MM32F3277G +** +** Compiler: GNU C Compiler +** Build: b211202 +** +** Abstract: +** Linker file for the GNU C Compiler +** +** Copyright 2021 MindMotion Microelectronics Co., Ltd. +** +** SPDX-License-Identifier: BSD-3-Clause +** +** +** ################################################################### +*/ + +/* Entry Point */ +ENTRY(Reset_Handler) + +HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400; +STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400; + +/* Specify the memory areas */ +MEMORY +{ + m_interrupts (RX) : ORIGIN = 0x08000000, LENGTH = 0x00000400 + m_text (RX) : ORIGIN = 0x08000400, LENGTH = 0x0007FC00 /* 512KB. */ + m_data (RW) : ORIGIN = 0x20000000, LENGTH = 0x00020000 /* 128KB. */ +} + +/* Define output sections */ +SECTIONS +{ + /* The startup code goes first into internal flash */ + .interrupts : + { + . = ALIGN(4); + KEEP(*(.isr_vector)) /* Startup code */ + . = ALIGN(4); + } > m_interrupts + + + /* The program code and other data goes into internal flash */ + .text : + { + . = ALIGN(4); + *(.text) /* .text sections (code) */ + *(.text*) /* .text* sections (code) */ + *(.rodata) /* .rodata sections (constants, strings, etc.) */ + *(.rodata*) /* .rodata* sections (constants, strings, etc.) */ + *(.glue_7) /* glue arm to thumb code */ + *(.glue_7t) /* glue thumb to arm code */ + *(.eh_frame) + KEEP (*(.init)) + KEEP (*(.fini)) + . = ALIGN(4); + } > m_text + + .ARM.extab : + { + *(.ARM.extab* .gnu.linkonce.armextab.*) + } > m_text + + .ARM : + { + __exidx_start = .; + *(.ARM.exidx*) + __exidx_end = .; + } > m_text + + .ctors : + { + __CTOR_LIST__ = .; + /* gcc uses crtbegin.o to find the start of + the constructors, so we make sure it is + first. Because this is a wildcard, it + doesn't matter if the user does not + actually link against crtbegin.o; the + linker won't look for a file to match a + wildcard. The wildcard also means that it + doesn't matter which directory crtbegin.o + is in. */ + KEEP (*crtbegin.o(.ctors)) + KEEP (*crtbegin?.o(.ctors)) + /* We don't want to include the .ctor section from + from the crtend.o file until after the sorted ctors. + The .ctor section from the crtend file contains the + end of ctors marker and it must be last */ + KEEP (*(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)) + KEEP (*(SORT(.ctors.*))) + KEEP (*(.ctors)) + __CTOR_END__ = .; + } > m_text + + .dtors : + { + __DTOR_LIST__ = .; + KEEP (*crtbegin.o(.dtors)) + KEEP (*crtbegin?.o(.dtors)) + KEEP (*(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)) + KEEP (*(SORT(.dtors.*))) + KEEP (*(.dtors)) + __DTOR_END__ = .; + } > m_text + + .preinit_array : + { + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP (*(.preinit_array*)) + PROVIDE_HIDDEN (__preinit_array_end = .); + } > m_text + + .init_array : + { + PROVIDE_HIDDEN (__init_array_start = .); + KEEP (*(SORT(.init_array.*))) + KEEP (*(.init_array*)) + PROVIDE_HIDDEN (__init_array_end = .); + } > m_text + + .fini_array : + { + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP (*(SORT(.fini_array.*))) + KEEP (*(.fini_array*)) + PROVIDE_HIDDEN (__fini_array_end = .); + } > m_text + + __etext = .; /* define a global symbol at end of code */ + __DATA_ROM = .; /* Symbol is used by startup for data initialization */ + + .data : AT(__DATA_ROM) + { + . = ALIGN(4); + __DATA_RAM = .; + __data_start__ = .; /* create a global symbol at data start */ + *(.data) /* .data sections */ + *(.data*) /* .data* sections */ + KEEP(*(.jcr*)) + . = ALIGN(4); + __data_end__ = .; /* define a global symbol at data end */ + } > m_data + + __NDATA_ROM = __DATA_ROM + (__data_end__ - __data_start__); + .ncache.init : AT(__NDATA_ROM) + { + __noncachedata_start__ = .; /* create a global symbol at ncache data start */ + *(NonCacheable.init) + . = ALIGN(4); + __noncachedata_init_end__ = .; /* create a global symbol at initialized ncache data end */ + } > m_data + + . = __noncachedata_init_end__; + .ncache : + { + *(NonCacheable) + . = ALIGN(4); + __noncachedata_end__ = .; /* define a global symbol at ncache data end */ + } > m_data + + __DATA_END = __NDATA_ROM + (__noncachedata_init_end__ - __noncachedata_start__); + text_end = ORIGIN(m_text) + LENGTH(m_text); + ASSERT(__DATA_END <= text_end, "region m_text overflowed with text and data") + + /* Uninitialized data section */ + .bss : + { + /* This is used by the startup in order to initialize the .bss section */ + . = ALIGN(4); + __START_BSS = .; + __bss_start__ = .; + *(.bss) + *(.bss*) + *(COMMON) + . = ALIGN(4); + __bss_end__ = .; + __END_BSS = .; + } > m_data + + .heap : + { + . = ALIGN(8); + __end__ = .; + PROVIDE(end = .); + __HeapBase = .; + . += HEAP_SIZE; + __HeapLimit = .; + __heap_limit = .; /* Add for _sbrk */ + } > m_data + + .stack : + { + . = ALIGN(8); + . += STACK_SIZE; + } > m_data + + /* Initializes stack on the end of block */ + __StackTop = ORIGIN(m_data) + LENGTH(m_data); + __StackLimit = __StackTop - STACK_SIZE; + PROVIDE(__stack = __StackTop); + + .ARM.attributes 0 : { *(.ARM.attributes) } + + ASSERT(__StackLimit >= __HeapLimit, "region m_data_2 overflowed with stack and heap") +} + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.sct b/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.sct new file mode 100644 index 0000000000..4cbfaf8ce2 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/linker_scripts/link.sct @@ -0,0 +1,16 @@ +; ************************************************************* +; *** Scatter-Loading Description File generated by uVision *** +; ************************************************************* + +LR_IROM1 0x08000000 0x00080000 { ; load region size_region + ER_IROM1 0x08000000 0x00080000 { ; load address = execution address + *.o (RESET, +First) + *(InRoot$$Sections) + .ANY (+RO) + .ANY (+XO) + } + RW_IRAM1 0x20000000 0x00020000 { ; RW data + .ANY (+RW +ZI) + } +} + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/mm32f3277g8p_msp.c b/bsp/mm32/mm32f3270-100ask-pitaya/board/mm32f3277g8p_msp.c new file mode 100644 index 0000000000..e9cd979b2c --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/mm32f3277g8p_msp.c @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2020-2022, CQ 100ask Development Team + * + * Change Logs: + * Date Author Notes + * 2022-05-29 Alen first version + */ + +#include +#include +#include +#include +#include + +#include +#include +#include + +void UART_MspInit(UART_Type *muart) +{ + GPIO_Init_Type gpio_init; + if(muart == UART1) + { + RCC_EnableAPB2Periphs(RCC_APB2_PERIPH_UART1, true); + /* PB6 - UART1_TX. */ + /* PB7 - UART1_RX. */ + gpio_init.Pins = GPIO_PIN_6; + gpio_init.PinMode = GPIO_PinMode_AF_PushPull; + gpio_init.Speed = GPIO_Speed_50MHz; + GPIO_Init(GPIOB, &gpio_init); + GPIO_PinAFConf(GPIOB, gpio_init.Pins, GPIO_AF_7); + + gpio_init.Pins = GPIO_PIN_7; + gpio_init.PinMode = GPIO_PinMode_In_Floating; + gpio_init.Speed = GPIO_Speed_50MHz; + GPIO_Init(GPIOB, &gpio_init); + GPIO_PinAFConf(GPIOB, gpio_init.Pins, GPIO_AF_7); + } + else if(muart == UART2) + { + RCC_EnableAPB1Periphs(RCC_APB1_PERIPH_UART2, true); + /* PD5 - UART2_TX. */ + /* PD6 - UART2_RX. */ + gpio_init.Pins = GPIO_PIN_5; + gpio_init.PinMode = GPIO_PinMode_AF_PushPull; + gpio_init.Speed = GPIO_Speed_50MHz; + GPIO_Init(GPIOD, &gpio_init); + GPIO_PinAFConf(GPIOD, gpio_init.Pins, GPIO_AF_7); + + gpio_init.Pins = GPIO_PIN_6; + gpio_init.PinMode = GPIO_PinMode_In_Floating; + gpio_init.Speed = GPIO_Speed_50MHz; + GPIO_Init(GPIOD, &gpio_init); + GPIO_PinAFConf(GPIOD, gpio_init.Pins, GPIO_AF_7); + } + else if(muart == UART3) + { + RCC_EnableAPB1Periphs(RCC_APB1_PERIPH_UART3, true); + /* PB10 - UART3_TX. */ + /* PB11 - UART3_RX. */ + gpio_init.Pins = GPIO_PIN_10; + gpio_init.PinMode = GPIO_PinMode_AF_PushPull; + gpio_init.Speed = GPIO_Speed_50MHz; + GPIO_Init(GPIOB, &gpio_init); + GPIO_PinAFConf(GPIOB, gpio_init.Pins, GPIO_AF_7); + + gpio_init.Pins = GPIO_PIN_11; + gpio_init.PinMode = GPIO_PinMode_In_Floating; + gpio_init.Speed = GPIO_Speed_50MHz; + GPIO_Init(GPIOB, &gpio_init); + GPIO_PinAFConf(GPIOB, gpio_init.Pins, GPIO_AF_7); + } +} + + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/board/ports/user_key.c b/bsp/mm32/mm32f3270-100ask-pitaya/board/ports/user_key.c new file mode 100644 index 0000000000..8d6ad1bae6 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/board/ports/user_key.c @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2006-2022, 100ask Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-06-06 Alen Add key code for 100ask f103 mini + */ + +#include +#include + +#ifdef BSP_USING_USER_KEY +#define KEY GET_PIN(A, 0) +static void KEY_IRQHandler(void *args) +{ + rt_kprintf("Key Status: "); + if(rt_pin_read(KEY) == 0) + { + rt_kprintf("pressed.\r\n"); + } + else + { + rt_kprintf("released.\r\n"); + } +} + + +static int rt_hw_user_key_init(void) +{ + rt_pin_mode(KEY, PIN_IRQ_MODE_RISING_FALLING); + rt_pin_attach_irq(KEY, PIN_IRQ_MODE_RISING_FALLING, KEY_IRQHandler, RT_NULL); + rt_pin_irq_enable(KEY, RT_TRUE); + + return RT_EOK; +} + +INIT_COMPONENT_EXPORT(rt_hw_user_key_init); +#endif + + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/figures/board.png b/bsp/mm32/mm32f3270-100ask-pitaya/figures/board.png new file mode 100644 index 0000000000000000000000000000000000000000..fda78087526108ff430f238075ed8f29dcb9829b GIT binary patch literal 711438 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�A4?YzdF={21FfDbJN5pR z$$G@u(8)*9dZFLXYJZ3!Xa>qpPUWMdVxx-&oj# zcO$GNORJIl?xZ?1!`z#tT`=Yg?Olc*xRZ$wKFrAfpS}N#lH|C~{NX1eO?lJajQ8GP zW-zdXH-sZVD}YWSDUvIRONuK>+E**B45^j$-xWnkq$r6JMNb$K1PJdv2IIXq-DBFj z@>S^~-Vd4WE6aCxbx;1z860#~W<+FWMP$T{d!M^$R8|+9L65h=h#mn;w#^yCG5|o0 zKr>E)$YF?~H4uFZ0RW!ndNfEfGJ`P;?AeDz`$^NuX9oK8j2M><1IQ=@?pikld4jk& zXW)ifajygp0>fY+L{1B$G-A$AYX;7AYS46!+8{wV=mvy|KSL&iWh$Fe)lk6o%sAsC z00?dwf-Hln#QHtV!hs$DkwOTqT94JA`{1PS^!RBgozGRYKHcCjn5oq-h@ON%>4+=h zKs=3emvm48Sll8a;Loyv;hGOzD^OT8H%9aXSf(FzQ5b@^Wkf%#>Do>3)Q6Gki6Px} z226=K#xe&7hw6h65Wx@Ps?G8x2WJ^@r60w48FMQlhk;PnaOSa!G}oaF45ex^OkeJp zGQOugSq9IS2fHr zk4FcG>BB~*DAyTOfb6X^|6nS((qn5VBti&84wT!-s)a}a0M_*>eU_n}0CE`N^_#Kc z)Avj|M~|I=+Vfh)+Q0!AIs=H55k=YVC6yJ%n8aAdFHk~q=1469Ep`ls7KPxc1EF;z z5kW0CZ-c8gfMmxY)WP#$Y8Hv~ceu|f}+7-?uduLE2kF)jmut1gJ;58VYYj$}t4xY3Qv#<(oI zJn%KOV#R~^qJHz*ao;gz07~ZzFp?K4T4zRKID9&Rn%1ixUAXdnKN$X83UaIrGcW*> zK%jdC7-al|5He?P5)&`~c_rJU4!j4hC*YoU=jcm?5-j?_&2ZKFaQ?{`%n(BEglp%6 zgW%}71p0?`h?1OIbH)4rB2>G0-|+V}K8`gD7zhYFGJ%pM;enKV>&rBKY_cW1RJ1sh zOHV>-xDImNmXVLW^P92uzkLktzj_}1d-hq2`q?{XW3Ml+#>*PF%w%3Y zAaY%n%+}U`;~p?p82cB8tM)OD)-)JNMDJT8C}(afw{2V*fF3&r zMf5=muN~1%@hxbCe|`%H^?(yP`^I`AfCygHZCa1|O)JNL$91TY<1iAH(KqVqSHXq4 z(+%_1Kkuqj;CC4isF)`H4NtGzdi$wj$~v|ySx;%`5&#Iwxm$_evo_y3xiCXhEX|DF$%&}*MNqt+aSo3GuD?1Gtz*q7gQF+ASkU|{n_AJ5}X&9 zt(XX)VsO#~m2(|jO8_V=+=);(i0CV_rPB*%I=Ei=HI+i9w-2`P6@#U*!F-IgmMhl4ZS z6o;y&G7^n?B98t&d!Z&vF%piIvzY_^n93j^AcBax&1+D*cFDM}xt@U*Jpm(ivHZHY zpfUG~XAPm|0+Tshb!oW5D_<+t#ok)$^gmTLcNvy)rV%v)3D$t}6mQ2}0p^ z>Z};)Zm0u$A%@m~j&TSIuUd?B&t?ql+YLQAH0|@A889wW2p$hyp#X?DzT@bz6Ht4z zWW_E54gy6pK&dNXaChWvPaI*o>hX_!_)q_ObBSfH+j7@_;I91uaBSC)KT7q!)c`=a z>IX}QOKmI5^g-!-7DNg_9wW+4T{7gF5Y+xb7^*s}q!S30L0t`Kx%E0UUNtHv&kYq^ z9fa2NR@qwG2IEjQpuL+8!nf$<8y@_NFRv-H-D|gh>K6ch0RSi7{_FoI@JtW@2v667 zsWvWrg)~+HQ{$kLZ=4ZO@_Hco{ZN$wE0k&WJmcxdfUl(qYd-%)Nbc%>;W^A+1`hAV z(BWNBF0t`6ESum}MuGA!M}!44@H z#PSCpLSW&-{0BQYlu4qi8__doN;59=VX2@>W6c+5=siSb84K>b1~uzPb$GdsiVjuu@a1ekw7bkN0)lC<^)&?y9_?@8A=;DIw8B2G& zd^q(C8PcM+^xy~nVEx7|C1uCky!E0MmR1AXn7lH_;6G{EHwU9#rM9*}<$Yj9v>0Q@OuW^|WP_YK}Teo5H2k(HpsUiP4 zMPe8XhfXEosa^iuvUT_TzqNh_$rbF%e`aAYdHHKf?WaEs0Al*khsDGje^jZmhY7D) zigjOl2xorsYeY{T1=pjMu43BJW2d0@yb6}drn^@hgHav(PA0Hm)dPRuxM2IE6=>c# z4F7fC(Y>1<1pq1b{MQBL^c|&^r4Jnd*W-{|?}ji&^J@MbSHo4~!`Ywx8hWZ1V3ipR z=OSEBfN2pYl-0puCSe-5I$$M;m`p4QB$5O=rywdoGX$|DLD0wGaRU;a`=MYC#pC#> zJCq6$T%ew2fY?VAnNk>o$QAWMgaC*%ISRlFyzH=X#P9?Hy0XDSDpW!GW2RzFK? z>JQh=S5Vus`RS{#yX{Qbg-&4I=9}68v;n~JUHv~GR7%nGu?I>ii)m4iOb-al0Ngt= zc)J^F;G5S3h#n9k%$jFBGniqq4h{}83Ae)A$1h4W9Z04Ll4(FOfDz9K%OQp)&5xvF zW*dZ<^95&QbZ~I6gNQj20diAbPmkpY38iM_gy_wp|L)-6;4s&idX02$qyaq%%t+2C z0^j^*G;H4pcYV#cZ@3-@Q+mp+fHT+XUm5N#kF4Kv&z^D%o5-dst{MWc3jmJpdrs9^ zCX^aF^g)qDmU_LVZGLhs3a$=d;xqR&)xz7{08r1Q@2VFHBKlB!#RfE9y#biuw8FI^ za5YkL>AJk^6)w%&0|2^b!>`tFzO^!z>M>lg?ZyiScJr6?x>z&Zy5A5Yi)rS>2MP4j zCLvq{&-8*#a72~E0W7%v8uaWSh@U-ad2~M_J6$T)(^f{W{dN(e%pQT9XU{c21c?$!ns?xktoR(TZ;>jY9$GnW3w`$6;S{S^syr8xC>8Qv@Z^QxOZ`S?|p zE!~zi+kfllNB2B3Bx}9v2urkpW&FjK!3`C9x(5Q4A;_VrXr_aMgTsuV>A*k?U^cI( zq(&iTID$pVdJiY|n>vkc2M32a3TNO1p+TgKL494!v-u}$uKMjCRII%=Y`*fQ^T18t z0Dz-=p1e*n23AsIXc=Ldl7;%2mIhM?L8TBt1h^Z*SoFbLpbSM3Ki_3W$WN0QaoS?Q z2z5gWEyU7~-HX;+Dr*{KjNs_G1cvk_uWY~hcRm%WU2wRf736>m-iQ&p=T9`xmLFEK zTtODFY^w1{_*NURV)GJcAv~-7B^XZQo z;=J7@ov%irc0LOuUeV|o2L}fS2Zvctl`m%;W*OW_fh)Z^lh_c^10vVt3rsai6tp~O6L!V^w;@8V6Cwd6V#izk0%DzyF(sm?DXBs`11yIoqPg5P_ z@Tl{r9zO?d=m21pwxbkH80hR%4LP*s;XuQck6!z}JC9eW#Raip!zLZTxubhxkAoYc zkU8`qG2+d|mcuf=$aKC4xn>inrwO10?uHt;>gqtK3{Gg(_jM{tpi~0*m^};5pbqYb z9y?ZYx!wI5Qj{f{Y8sDk+H}>l&-6EJx-xqB@WCS>a%noWDBSA8s()WQWg^|dapxzuebBw!F z)i%z+)CgFKb|wH|t~I|f+*drh?uy%wRIq7zS-)W;18{!dd&#E&%}vRX2Z7k)V#_fj zdHN@Llm`~JVDSfUMen-@km~Nm_-9vLp3H>0;ci}lruSWs;L-_7v`hgnCrKlb(vTWY zuHSS``H8`bWW%N_69A6wd-0Vanl=#dl;%vz^&|{+5U7G^s~OK;p(om*_3s4JO6&BB z?uv9q>-X0#xar?-zxOwPUE$^x%(`tK*kSl@_-9W2-KCt*ls>54uR_oCRk~?Y4j3b^h&=+%G8ii6WgT0v5*!DH}h-g3DenPk}-^0$r~@D z-?f879yrs%^&!)^%M|lpR!Om`ki_5sQvp408kn<{U+lP9G6bIbTDa>fC_hPDF(x)0 z(mhvwf9>{9JyyAbi(|{xcklBz-S+9ef)FH6U;K<+J`Hfg~|1Iz|*P~j- zRYC;w_cHQN06;(lAKcB0u=u_k;a@x^Z<`teQz9kT$Amx^6Y5V9PG>Z^Q^p8hNNK^g zjLx`T!EWlR3Bubr94#%YA^L)eDu4uVVQ`o%G~qTTeibh8^p=)r=iC>tWBV) zWg3jj1Vr>9v~o3?Z+ss-jrA2PxuZ{o;US4zZn>qcVuh9gBc1`ncl|%`^udn{%Bed` zD`os7G_-sn7JujtbiMWl(%l!QT4 zVhxxPGd)#?Kc;|0fqINOy1e z<@!z6ca+%Lim_?SHGKzmr(czu@B2f6ANWn6cVp3o=m{vjuS2T20%Bkp06+@(;Hs?w z732ap6v}5>JeP^+gKzON%)j%R(GR%}mgy_G!vjD{uQ{cwb*C!O#EP(C(^XO6svjMH z_wN^#YFy65dclMqxPwgq0RN(9xWWMp9yyClZ-12@Pq4m8}Qdw!0LlgX+ zt;=uu*A1Jmn{mVPFzdG5e)RCc@CB;2-6#}kT(-m8Tn}G!9TMjq=X(bShbn~#fE)x- zRB$$N(E|9~=5%mkzL9_r@JyN$5`YLGWO}vt9I6{fciEvRxDFT@a3eZy!)rVggt|ba zkY(V=VqoDKpevS_@r3UQ0U!cm07S^XxSiA{U9r5M?Tp<5FpUYVs+(acjHFH85o&sz zOTlSd7&|!3dYA&v>=WxvImM2fQ-qP~hBmmTq;r{2bCwH@$2mw<>=16;v?UE}d1S}S zv8H7I;rl%<3b6uvZG;kdTN{z;>Os1v4Bg_Xf{1`zL8%i9gLns-_p0x&zv9;7bz7&1 z%~#%X2Ds&$M_&Ef)tb_?Q7Tezkn2h41A9T``Vr&uOfX}z7)(nd-SHe);(W<&9gEQTjq96ch1*0Z<`V|bRX)J4;`%BFQcfSvENWk&$ zlpfaM;Naje)3{|*B4aFKR(k*ek?VmOTy!`%ILvOip@3z&k!wqWh+Yu6&NNKgB(&mM z+)ML7SdDGcXcIXKKJhy?1YpVg5DhUc2^ z>fS5APl#x@b2&3`4pKpx3Mx=6`QR;Z*9LIB2^O+uJnqcFm zUy0(Dp9rESI@4{bEDX>yW-=M;r7L<}kb+@QsSZq!=E!pH;Naje)o?SShzCK$$$A#U zpK&8T$yhTikx>YQ5XWHPFbT(d*`ZK40c=CP2>}rTfan`z;F$2s;ySoyC6CK0h2gc% zFGLE1S+W}0%d!eI4a<@v?*I%-VZ_0ij>)}#tQ3axo^WuOEljTz#uP&3=!Q*KmmXd} zMYw~jUKhyS|4YQ)FMvlERiaGM=Ycpm#IUMpxN-wpuD=4*HTR=_+;!Lehmi3mzz%$7 zrrS~qv$E$aDns|60(Yi5mmur6+_UHCJ~<;~4tcRvUj&%`&*CC zbUU&^h+uH3bw6W~1yt)>UCg;$PePBMfrzD`?os`5VugJWmI5~%=$eYy*>hl; zVkR^)?8D)L%hx~-R6fMWVXnZzjWh_6O~cAW1do}`nd_!;pcoxLB7zV)CIfW#`W^G4 zL$PEcLrAt~S4pF?3;t!RA-Sq&@uVi>h@U+PFax^Ik>Pujnz#3B zRxd{VwzVUFtC=L?17{&-;wX0e(GbFITwbt)Q@I4O=Ba1f^&flj_^xyvB9$>NOFlP3 ztCt{pd}EFpw4Et!%RS=v>v$gF9jOtrrOirEap_M3_$648d&fF z$nMG|w{*C?Nq2SO=(qm?>E1qYrhsSqV5j%E`A_~oG+%q`^fu68Zb4-bS0kYITgI6} zARuy$>D2;ib3S z03)45B16zKFlyAGvWWNp{r|<{>#r@pB0_BCAm%DW@PN1)EZxuSa6M`1B4@cbR04H3 zq0ogk*VEv7B&U${}M&_ zTT`FLY*reVy@3V$7p%SN+y3y9T{GPl2f#b82@5~)L4;N=F1sv6W9S`F;U?894YGd2 z1`Z%~{JmX8Yr1gG0IpbJfDY3^@9wwJ@ygQ`FSl;%)mV7@0~If~5PEjLfzH=o0+r0r zGc_JZs;3u5CJh)0m|`EAd-fMUMAw@yjea1wK}FN+qhZTdwBC4g!R@&8`l}e&zi+~) zlNW@XWx%!Aq|Y^tBc0Zv#8ogodwYYmE_ecyCr?xgP4Y_P0Js`K{g$m*aQpoQUx&kF zxRC@DfXJcj;f;iXh(SQ`n8$0`lWHZ?98{3t4b+(4EJOgZ>c!a@mbD~cBxb{0x9W&r zIES`h{s@doAQL?}Il#0SP^PD3V9_!x{^)N(6sKoV7e9Xn=N|hZxISK^HPv+ydOEvd zF5TOK6aW7Akb^ZNpS9lfel%Wv(^NLqtb1?}?N2-bEgAu5x~a#@4JZS>P@{w327{gk z)YNF7plOOd|M8zV`P4HbpUuDaYOK5ezLMJ!KYt$WPy7m;8{nXJJrHEfdxJB>G{D+P zb%_B`VX|lN#PT^)%<&-$Qm6(?Kk}RK)R*pwISK(01EzG3oe`HCV~n_y2NfdtfMJhW zo-ZncgR3!fth6;OQ?pG{4tWQrfU6NJ5~Ml?I&P$aTuBK_F4vU80Mn3N3L^j_S{sm; zA>7cRr*qpoxLSImwhJ#jkFGaf%UcHk$o?P}+qCE}GD5zbD z^X)kLuiwU^yY5BZ#*LM08#kb*)6gcif$Mfq3(q4z4qJ8wc^c+6gUNN0E{uP5{5|*1~3KL$M$lc-SoY`+%m_! z1_54o@pW<{DC;+FEz~n+Mo6n1g992uK@lFQyyrqG1w1mSI}9TFi*O1mjag}2mfSTL z>*}ui(S{A191GnHLx>1hT_c*W-vYs76Mk3(i~&P&4K;PnqjjhZ@pGrp@lxfJ6evUe zaQR2Q9H`5K@S07KJl=}e1pw)uF2v3q2LN=u_B=XYeGb&sP;}P$p@VxcRz!>lUJ#e* zMK5~2MH!bP$B&`o)tASXmep&4t8s9xZ_?+9I72kXplHl?+FS1v5pI|~gCed*5OHEC zBnMZ9Ah_I)ak*T$4z9;d$sW;@{dXp~L12bI62`#E_yrW_0H^^jctONGA^v=V90q6L zOa+X@%w|2G#V7;4=zQfVFx>-4S^7$*x9ofCU%VWirdEg^4_vj42(4UeN}rU$M1N5= z8AJ5gAuwG<#tY_jO^pI zX-u`+#x!svV;O}fw3iT5Hb)9tkq8qQYhW-;=?Sh+-dqF#Ph$%f+;M*ejLURXO2JMF zgKOYg3S3Vjn-m72G9dX)t>t`-NMR)HjqgM-y{IL>87`g;rhscnORG6+Apn&?Ncr>Y z!r%bQSdtaR=fuegQvkz83WEqB)D0pPsBxVOu7k7e2?D1BZe$ABn6N!LulIT>&M8Vf zj_C3I=y>@V3>`b1_jqsfeAI2+hWWSMkyjGKY?MB8UiWrVGyr_fEvVac1)`@8LrcVM zk5h)y=zg;swQJW@%($HF?neLq1E$l5wRJZF5x_-1z|wH}eF(1J08e8}`IQcj&12ue zV!%qCJhjHT#<@NMeW&~`g?TGmWMZNx_Y2;rB)U~q_iAd{-(g;2L{*7 zbbH1#;kQ0T$dZ8ikUX+EGuO~m1JQ&ApO*qsah};mrUyp64T68c`1h&c0t7FhCoz>9 z0khJ$>`*-rF$5~t<_te97D@;RzdXGb9A*#wdv{=9-;R;LJx#6H_E+DAv~<;!)YtXy z%Q*foe+yvvl`#AJh?WM@S|umE1jJPfA~~AUm4Sh210XyM;;PMks2l>p_>fWpAmADP zzarrpxYCcQUJyByN8}^h2L6yUdAny!I;2J@Uwi5xX4vcfN(aXG}+`B_I1N)_ndC z$}Te(BT^4p5lvYfLXmHQ!nL7kF**^!4KgBSVb_)vxNei5iHacZ#=;GodIn4z%+n^H zDTR>(u0?Zu5fOmMwdR6wI^YaU9kP|ID5GH0JKJV6%haQ;$@*Q<=ovF9?F_+GSILRF znUS&Hd-j-eF2xZ$c?kQy{#6(mr68L^-R3*7?n_?*Ep%DpAOFgQjZWGxJ@-p! z(Fm4){0n6#{p)%AWn6moc@Qa##Kn$^7?w@gNLT53=Vcg~431*)Nd>roqT;;~W~o4&X*<`AyloTR9xVCTXVCnwjqaEhM}nF-@g+8 z;HqnYr=barSKWxf!lgx*#W};^k^Q*z$}{MCV`h@1%wBRBJRC}c>)?74gou`|9<{>Z z%NeM%Xe@JPdbSw}QxcR6tLg8)R9pNe0BJkiziV8_ii} zj1-2=J){z-;0HvXOcB^v7E5?GSB+_3&2pojYM{d4I)@lCSH5lkU}Zs z*<7YXPai}7{`U%!>Y%cW`mNU@xMamNv}}5yvW&W|*TGN~#Lu11d2IaLNr-_UmVETH zK#4y|UDFUbb`OdT_pjP!rXKr{gm zT~nU;k8>lZWQv1BH8WydCbMrn>-dK{R2>2V9OIC~Y(^RA!|{Lpzvz1FrThnH!C*R0 z|Kz*4^xQ8i+_Kq+z4MHX5qSnf0OvLam^KKm^n$AcmUmmJhJ2gkeOv=q220lgCIFFY zvgivtOgE7eN3j2|zlP|EgGHaqxq-y_vpD<@e~JD*?@mGMCX>8)9*4jAm+0B~Iv6W% zLCP3|I?#uc-}}Gldj0vL>vqdPb3KR0Wg3&m{-Xq_33CJ|*cg?_AWr=IH_`dZGiG}$ z;Vr3WOxcL63vvO()nFPi@|0srJ!IEdHX&9&%~w`#Oeu_Jd&4p~pr^pJfgIOVmt8kH zYgvj_mYwmESn>|Jys^3I(WggYKXwujDQtRE+crlBR|aeh_(dA3I0ILQ@+A2YKwR|& zJpXY8o8IesHZN~t8sX)-@(s(@Z#Va|xjZo#L)#NS#kohmpI@h*5)e_WsLWwCAbWjS z{h2Rg-fbT!>;%rhbRDe3F;$I3aq|2BiJo`f%6sg>_uq|WANeQ*T824>NFY+KzB$$F zX+G|sIlkG9B}@g=2c}OGeQy1f9WEmn=V08-MK;@TJeM7+4+0S9jo{!g=kbRK1VO}L z!hk+uA}=$Yu7fMRRw5Obsg+rXmeDwa@`MGCmIO0m zD0yRm${zWfv}KJ_TH==AHRp8xeD$P5l(#ixG79Rsc+}&IQNSm zA=Pmq_kmP4b$xB*5W+zY{{;I0A%L89rcObn8g#$A54!sASpLu_;0gw_9hl!(G;Cb7 zm5uNMQYgQt8B@U3XwIkuLS1HAQ{7MVUXuqz3>NG?msbjd5D+1hTi$`GR-1B3VMvw~ zhP~H2*OTB{1V9#JArV2u8X%V>$Jnxr6re_c9L63ZcmOe2lza&{6hMn)HzE-NA_OZW zg;Bt>xlD;)IET|e`WFlx*;ml<^;@pN(vN)({>5|0Yq=DX?Wb|z>tDsP2Y(y&TduB9 zsn&-2v}!)uY~oiErkP{W7_a!5Or|*&&H-Z<8s;1v000anZ*a{tj&a$cEI7-6*@iwA z4+RIMWkm=%I228I^?LXgEzkO0y1N5|C5B~3PaHwdj#p8)?fQcC+fv;f=-d4!GW|UT z*CPjlsM)v)lG_8$HE=x!p6{i^3=Hhw31ujkw^D9u*Q^Co#u^ex*2yzx889sh07zaq zi^y>^Te;*SAOfJN0`v)bs{R@emfU$0B(Hs#AE9p0iOKsoL+#pirCpFiVQ>!4P48kt z8GulM>z6E^&YYS0tVS}Yfg=}$%4UdtK^}+}Oaa%^X2{v>oWE5JDhjCGd^KEk_DOg2 zcmxCccS27Wp74kR=-K@)q+kfO>$VnrUb6ixhK?R6_;>*Dw9H5C#%)>3I*rK5qXn0f zXg>om4tHGxnzmmLPxFGj=cKwiFnC~B{=$hV+Tv8Y^2=(Rgq~_+BrN@D6(H+E;8Zl)i1p9i1OEXfY6o#Gdvn7Q=sL%8c zFVLfv8^h8@+1hByhKSzsHy8?iHU-MlR0{LjN;4u-D(06qC{XrEi^nl|;2_j^JZG7N z3aH(*39Yx?gN71~shqkCl4S6<&O^Au^D|#-{xKQ=f=gGS`F(d_@bE!sar>l*T2jZr z!GmbIt*_{|#4nsf?~XU140V`&bmUoCa~}?X5Xj+L)NR}Z-~7VbUOe24F4J?2H^vO`&LBMF`vgqBQ!hytis zzJ`)05XZReFs-!S_5m#Y;3udGc0RTPkzJg3&C$3zv4q}0c zmj;jS!{KjzJ@0XZ5C|SGsOW}o!6K~v{C|U|u5fKrgXuW%jjv(gz(Ek%lo6nEaay&l zH{F8Pn{FxUoVF)^I$~S~08u2UYnj~P!>dHU{84E*vzkX=~*@z0}v({|fqVi(Wh;Me~Esjf?4+<=i$@-HYE z$Au?<1|thNB{Bb5dY-wFh7@ZnRDox0$rJCoEz&gHrgi$HQURjG(xLaW5d_}3ZgvT!?f$I z7m+w~0sz1a4Th5KUW^sa0F;4#oc!Sr077kz%Yj9Uu;EKz&UM+goc{UG5x?*=n{TGP``O| zF)bYj5qx>u4FGjpZpMcH{*{vJDTjt_*TJ`N1@?X8FQB*Q*F$Eish=!Lg>QoN?tBv` zzW4tC07UeINYVs{3kGlsU&}nK{hi;1?5&LV{vxp~@?sZ`e*5QG^1$t=-IU$?vrr_FqN&ye_@-9q z-@&0!YBp@e)^B`gZ6!*Hf0EDBI?UU>a;~wWlYPWhiDSdrm0~mwB&>`HeBv z99y%NOF+b+>D5~SDk4)dhq?It3+Q<9d1$G^BTXE}bK#j^BQrRFm7n@e&=RayTu+(C z963DwW3`sZqw7AG;E0`W$Kh}O1j{~lJAx}0l~o$md)G;kpZ`Gj-TZgJ70*?_~7wW&>p78!1M^F zdR(Z2nQ8GD>cEmj_iMjXB`Gin}E^}=?hYG+sz%>wN00qy1IG_!Ot(Pl>QJ6smfF*^IvJA_`dGiqJ0-=|u zp#lIzNk+};4FCXd>jGp3deO7vRV3QZR;&&^okrxuL1g;6^B!Bj+s6I&;&EX*!syVqo{1P!r{Qt#d;|?9?%&IxkNA#x&gNad0ciTX@ZSG+%!m>bGuz zm?J{O6$ry+T@!V=p(o<#+w~@t!J*O38^N3PcRzIOD7sskP=Do>5VIJrD-CC9Ku=m4 z%QI}mU@D-ea!6r#Oeu^)Bn7w*Xen@(PYT0h8ZYgP!Xx920^9M1x=Z`T<(_*vgFzVA%W?Mx-!u+^d2s(oK1hyfP&f zs&AH|#FOaT{T_PWeiN~_{L5qSy!mL@wjJ)q%fqoi^!d^9zMDWq8L=}ba~_-QxP*9H z8#rfq`<8BK=zI5d3>_Z3CSYd2&=S^f(Hwhf)~-j>b=QJQ6*j>b8Nk}a;zr^!N^Z%a z#^TUUoP!!0yWv!#J1ftGsdnLgghhW;k>*VSgy?P$>DVUIp=CgE?|LGIAp}-}$`d0E zh9jQ*_7L!cs-Jn#unQLMOeSxqIO#mnEMscOdReG=~c<}W);!yD5hrAuL0UT`SJ3yvG6 zp+~pZTFhCi5Xcd-etF?-Xu+D#eHB_VQ8DAPu4JG_2Eg^)uX`$rko+MmeBcvkx$f4Y z>S)+@E!@qmh@ClFka1ayMWH4WkbVBi?bTIe271AD`>0uNWIzcZ*EV6^t+!y|o$oKI zy)~;h!oPS04*qQnLx+w+*K-^DdUx)CGBk+r+6@pxQ)yf_Wff2@(lXot^mKNK1VR8< zp20*y-c2QL8icqu0Nd3IA*L6!t=s}HKzhd-$D|M-`pj#X1Opf|J(edKmd*2vlfqzt z7R#xzY|4g&3fA>CHx~_aBgM$#B|CDjDj>Ol5+vFxKCgQ07AjmrSQG!@!V1PF(6%KaFr6xts9K8B7Rnpgt3 z9s|HZBoQD2ny#KYJExBu~=m3NbD2p_P_Gak&Uu>Rs@-t5ak}%pCZr6#MnJ2urjU zdu~^+g6{rm2rryjk^{Rx9lQ9ezhQbRJkxEdBt#G(if&62Y7BZBEYp=U%euqd=gd#O zi?&}>?PhsJprRkt-3;n(Ha$-rE-$n+n9`4ur7(yH;%X=?8P_n}09OaW^&DZ;4l_!} zYtQ1yKYblao6>G5NFTaJl%~wu&o7#T)L!ABTce8GQ4eWXwhyKqWnh5}N;BIcj z`rrFKG+lFTNo^2h7gqoF?_=KGA1UelDS>I=O0VfrTLo}6VugB6hENZvyU{+;-lVdk z;OZdk-C``c1u0_7u2doMvuCjPufL9= zqsQ_eoCB^W!POy~O{8)$0JYDV-#E+x_?UlVKI0tSukXg$M_;nZLov7LIQ`robe(QkgOB0YY66Yp#IcFFvGOAOtR%g67CbJ);=0c~tA(2&NVhuWRCOT#rEG+No&O ztinZN3*EGL9U*Lb(>zZDL=Zs6>=+L0KaRdVhb{d($7_AI5L~_%3-5mjuDaY3C(2Mi z+MfIgqGyigEi-xXJW^ekD%Hg5gotJcu;2znKZqF0`VT@N%g(yP?1ckbax`4C1dnw> zU7%tBM34�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

iGUFA^W?;5uzPioj>Hx!j895;dUxcb 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 z zR;+-LxF-|pOw~Deq7YB_?MV7>XYgYF03#+1ndw)o{jOWGKMmG&CJ}_D&Xo`Mba|cm z6t4qrT~N#^e#(iFjgo!xA<5y9=0AP=H}y@;5yvCdYyXGi9pEC?E{lhEz76&ugSwq1B{9gS}(Imy!*N+L#{MPK3 zT&#YA;)fu$+?ahJXZiXldERkmu)KkNc|6el)xYwwlZUavQ?+k_&pSt|-nW8DoP&@5u5vX&_>QV)Gj zbsFTXWsF?{L1PtgPp~)dvG{?45`4*$t3044p)6(J@g6*a5&`O_$X zmM2AC`_Br9#r9jGkr%%QZC$q2UKG9_kRYhM(RAIkti1jH7wV;R_})sSZFx@Ov^h7f zJJJke+iFF+elb;aKX!!CVi=|2n!W+hEnod7*8?Q;A=qalfYO0MQSCHc7m^=sM(ilT{7Z-Cam$aA?`1ZWCpxfDu5hg8ForvMNV zFW>Rlrd9w_sN_BlpzZ(aX(XoyawByS<_?|FxzTE$3E0(L)(0~JL4iA{n?knybx)23 z<@MbjX7LN(Zc`b(pcAj7`#gq6Fo_SN3`|)0BSAWO7+zY-ckJfw#FhHtoWb<{jTn%2 zXW`7g4OgL{C@$jTCexT*4xRyCG6t;aXl33tE3t*OH_=wRR_%Imz0+WWNHB8Fb~j=q zpTBF(@pq+uTwbwSU6n2JjgSdlV(0|a^q1wSm1u;_@3OY#Pt{{*_)!~Y|Jr0WimHVe zs=*r*YqNY&#ND{vj8#jp8o`n z%QD3_)ZOy^?%XK=3tOw!9IA+N1^RtbiOskwpb*~co*rd5V916x=jWT_dQ0Xg01reL zXagWXz3Z5MryEZd9P97mX0aEtY9*sfq{3Yu)eurBLpck=mu^%D1O@8V2YSylQ8qI1 z|6tI~WvWmJH&?ZG<+!ydccO%Np9*Z5X3nc1jL)1I@z7Gu-h9#u9L%#MSYlO%^_06H zufJTr3KpNhnPxp!Uh#L!E|O&i#2oz3ahmCgNke;SoEbl3YWe!sWjLR}@KE!3lNqvo zdvRd~&Ij?-5(qs*vKG>ao4cuR8FA(F>0eOlS6ZH7jd_`Wug;>4FWioO%SqD*{+VBz z?HWoES`XpfQcQgINw%CrXI}gq?(9N_jg8{of|qYok+Aa&pV8^jSGypj<H_{TWv^crKH|^!w`QTUmQCS{|n4)C<)712B zaY|=mvTim4^X<|TTXL<9Crpd@S=tuUH9kD=mi{zxBZDRAWTr2gphqF%ofRw{kETihY1y zSf=CFoh1|@pMjPGIS>>IKJta9sJ|hr<*nBvw&~=;1*D8&`2*dt4H_Q-;D{#HS;mr9 zv6X=2ja7tFh_pHnDJdkr0yBmh<(o*mYqUN~4da^?^gR(4>XC4fn#!SB^|@u!CGqUM zq5Q4Y;@-bm>q@f}8BEZ9{%o|)UNI7+sqng5kGFS8p+IW-j&J{i)r_dDtU~6mnin<% zLmkIka3Oh3k6@fot^MW#TPN(-V9|8uL_#vv{;f_`bb9(w*!)bK zwTZ9dFm3o}^lzN0is`><5^v<&IKptopUSZR)fD*gj9$^sl*dBJg z7?zh)FUSSXrGhGRKB;WYC5{Uu3AlQJvg6;EHZJ**r3Re7rQe*4$OS8HVwBs+Y?SDM z>iO2uP|BDkERH=bpVMB{4M=(r0y4su-%2mV#)_Vfub>%Ld^7J8OBcpK#vWwuCebMn zbPIHr<<=J8G9=*>D7f~$d>CE={m{rLtPIogAT}a)xBK}5T~CmCE* zW~z8*{4)AXD;q-bTG(JUN4|ptPkajm+A!FR?en`0zok}KpJTezkm(Yw3{GR>RRl3 z*M(FI8pFgcb$td_HRN|Hak_I%Oa{h))`1O68H62Z$Kcqmjl96fQ>^oSB%GvvRD3H- z#kHgo@=RjlCVa3AhKvu+XaR=j%ms!b(2N z)IlZnwi3>m_LBK7_0%QqA5L?jLS26qG19)U?qqlOM7W)nN-Ms%bN~88;s-=Ipfu=f z^<=>F1!u{=Z?PCH{GvwOF&M)YKJm($Wxl6MZF{UEZH5^ zdmgvAJ(fJ?ySuwB_UH?Mm%>6?Sa*qg!#PFPJA?ixj{%nt66$q~o#P5CkycZBwmyqy zKbK8BMJDXtL6*$1Lb|`3Q%5KjsXP}XYMqjrI$EyiY@g~ho^R(Tv0=3@PGMlq%wQPs z#U`-gb;X_jW9Ks5{{0!Z<)f(4(+d82{)#&Fw*wL{BtynxVuXkG|-Coe=DRb^4V|lqK%!KLx}Ctn^N7|)hdSPx+F3n65SA7{I2|rcS2hsIbJ0F)Q~%={r;s7z8Zt2 zY;Dr3J5CP+a=B~4uPkerkBmWFie=1IwBxt1X<`>vugm)OE&k#rp@YO^*va-0m_1Pf7m* z?S<8f7BY9l-6THe?#(E@l;xAmr?@IidX*!@Z5e?kqRGi~ld(fUqe*`tXfC`&C3iwg zT!pxl+T`Rfu&iR`Se|BQQBWgWgP-}wSFGMt^sI{>%$0VUPK2e%fNDb(!{crFFLP7J zIyAWXt{ydsQ)bAJJd)#$aWTw@?i#e17Drxk$Vjhh$=qYw16EWM_wqIVqhDu4J*Rlw zGIFi!LE4IC#^g`x>;M{6yHHWdun%OjX1i@foK6MrS%6iNz~&>^O}UQQ+96H;JAAiv z*(dA#H=FvqNICQR%Ixj5&mtSj^7V_Z z5#NAwG>&@YL|>#0U2|jXhkzTGsk$qWN>n4BM-$%D$w^Tv`{hgorXofz0`}Ih*k% zUFP4n-saevbzd7U`s-0EdG!J>BPJ8&;A(!K6cLd0lNt`LQ!*3l7*ZU;6vT59^LCX5 ztu>|{eLg1va(4RY&jTrGFXWzf+jDdH7yG`SJIx<(EyQN7#YtLt-2 z7+JaHmmilz?_HM?g2(O*_SB)@N!y)%Y%ql3mEu^Yz0lE0A$3X*oq-uSz)LRN)$Ko@UI1jS#z^ef0h*%q4Nf z)&5u&ACNR=#j^iiW8^4At!e&h_ra_H1 zB+SGOH|ATf>o#x6S9PJy+rRWJZ?fMrGjed#U6~q4XUNWFVo#1IJ$U9Ftx2!LaMS%J zrc2++lxVFXvE4IlDMjr>^cGvi>uug&H-b$Uw7Zo@j6-ba&-RrSvgPd&)x>9{B51=m zZ9-1VF{WyF1T=j(dn$ca#=~G4akmBfzTt(l!XFJv%3+pa7EcVs5D?!n7$ZL^MR@;) zu*kIk0r@b;t6tSRMmw_yF$)_4Zy%h%lF_W)fa||4yAIxXv5fOeN{=D&Y0pSw;@27) ze*Q8nuZR!A_siB(ep?uBn7Ea5XO~MD{KHhRxh6Be9IBMa8owC|>3HlBbg3BS@Ddt4 z$Di=IH}K@u;bVRUB-b5C)Rp-E%`AIft4yejZ88rZj1bl6C_)c2kW$dyaVNZ2 z|Ih%1x+1dT_G@Idh$*YwQ@$t*e2U64YrW_<&XWh>^l2nIT+)6nc-Q!KUU#?pWs~3P zkp6zx#-AtRcszKHaJH-$%fnkAn}s`8E}qU$_N6LI)h+kHX_089pY3{tjn=ZcjXR=> zIr*(Sy34>7^%;5y#c*|);}dZ>5@rP^oIk<3aravdqglDL3)9kcb6QQ2%mog13}G5B zRu8Vmu^IlvhwZ!arbG@?t@EV|skWnzuB}Ton(-uI-++@Z1*shwgdIT37vkgllK||z z$9(0v%gK0cr|#ydt2UiB&Fs95>l5ZhRSdc64}$f09(i&Kby>`ebhhko?ucmOc#b%R z2S_P~j-q$RJxD3!Ip{jNdE>XZOjGe?Qd-N4?)P4l7%ON0YU8Z2I2Zb(boAu6Gn9h|G z8juU&4kxIaS((-aem@{c88BF%+s~mKcZCbJ3Hn*iW!Ij&9a47-@Nz zSC=yvsUUG}rQdOA7|otrp$4~RY6Iji%fz*OoREZrm-A0^6U>V@)C-Y6nJd#ESUnIW zQ(o=Ue4#$dGCk5c z2-qTmzJ_j!AfL5x8IrqYu~A?s&pf0Xakrx#wVXK@i~F{?d8^0K`#z)RY;0-ywH5?6 zIx`3rhEy`trk8^lNc)`EVcOyJ5phpRl?CMa+^cX8_$gR8YH2fm(bixN7Kj-7x>p zKeWUR;W;u()OdA9xP|1eQ#n}x$uh+lw!6LdA)%XG{0$MH(#gnzPaeQ|rQ)+1wZO0q z>8_d4BTWB7Rb_~VxoKpQJJ2#0fXh&%DxR`I6RU8yi+ zmtZ+%ll*d#vo+yB2{T%woknA!S+U~Rmo*1Y!V_P61O$0a>!Z)b zU-@pMv{F$C%>q$iqZrh;ofXHJUO}q@3ysa)zTzq}dH7)R`TG68iCCx#yOM`>n*)Gj zKLW3Gc)={W7;a<&-&Dk<*<4qNc29H{Fl!lg%Vz?7BJYm~0#I`m{JXu6O8aJ8-3MMy zr3fEAULCKG2JqeM=BctsKbk(;OYN_Ge<>hdM9QP_da;>g&Q0&)jqLrWcU%kFF2ZUE zot4AXJCq1btaoanp<(LuNu8iKtzn^1cJe3$lJv36`&mf07V&?!h82=83zDEI)l2K_ z2)A=7yG8q<+MCzWRctm=Odq?teRX<4%M||Rl4AA8YD0PR}xgQ8(Fh949nY*Rk01jdsIc5 zO44hm;X;TQY5;y?)E|#LXNU^K$_^1%P@azbh9#lzkjUT|>cprQX-V{5%!N0(Pl1~X z0uY7?6S0rR>;p9Bx`RI>eKeY8jB~|4_dXWW|#*U$ivD#$?6{J1rub?(irT( z*5GWfyl{w_i$7J4Eq#pRsYi52sdoQRzqy@gKWWc@qy3Z-2PtdK!2Y=z9mR>fOgUgB zTEIv&2Z^p0~40bfJ$Co;9CS>nTiZd0Jh$W*|maj??y8Dupz{;1!5S%>!WzNfK-Ve6wh+Zi#qr`OJ6{M_U(5c<8 z(X#3NSun>@WY!RB#F`8a%~Hf5DprcBVj+ErP9mO-B8aRVdF)4!Qd~3c*uB^I!uVXC zpfBx97}9{mUTFZD%T9bk9T?}h6v}$ms=??<;>$w?3D4wfA_pe_Z(08PmMp7GTh2?a z9AY2?SFN;G4)M#u4KGei)qwp9N?;3CNqZYRfm+Vn5(=zC;?6(!*k-4pEyiy&XB67l zM0=f@14}vVYx-48#Y6w2?R49gmwc~3a^(LG5uSzh@wWr;E7>wu($o

*$uUj2zT8 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�t`LO8rY)^P%x8aZhIf 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%0Df(oonQCV>S^R~8`qqxKieo55 z>o)-vACldm5{45sM`$@|)80kJ9F&p=Wwe>b97Go%Ysk#Cc`Ammen*f zGJ*d#s3?-|HyiDgxv6ZNO#gy2vB92J$Xe}y4ELwNS_#*8dzF7l2*@1}$}bCqq(! z54{fs>N-ygD*uH#l^iy%nzva zqK08*D3#(Wx;wuMr9tW`yYpfo`lxo?Nxc*%}w%T9Y$ZJ4t1@`Sel`)NmJ=SpSr~_XTteQ zC`Nrg`QEPm5b)Prw3HnHQ(FP0<~4HAvwWzXu3MJo{T|md{}Y=uF?f7_J~+L;F2T`#e;>F| zsYi&dML@^;GQw~^4otD^o{pyUxJhhXK-NRNI;02LRGTG|G0u;Ha; zqVV6Qd6^@ir=?nP-(>HVr7(0X&;5>qXx36()B)9Blv(zj_!6VhNHv&_&|av(INftG zN3YaH`E#KweU+b`iA*)ibiz=X#>!W!4)Pg#Ez;6w z0Wolsm}z}=dVwC|+1^IOdcE-|pQd5LSO;`?75}&2#;tJONjZdS!G#aG#=z*go0pPE zbl&t#Y97Wxy|H2x-HcO&6VF{4M@fcYOaKFnZz;M^=x35Fg^F|)XLGvILKK?d0UX83 zzeL>JzXbyBcGA!s_Xd_W)#CIBqp~sP2faep{l%M`RKbJW;t^-OYyX`{(z5{!zOPKPAK+^GG{o!pp<*i2WS#y!s zvN)#|&A0D4yy_+9WA=3F1_3H+hQuyz^0XbN1S~#@ z0yoaz^9W7J&dZ%BRH0VZ0 z*6~lOH=QpT!jQdPD9PYowW1-}(MQ&&5KY?n_w4K^Y_|VkQK5k;Z8BEvCHV!|;qy&9 z_%Lfe_E^r>ZxrIcjvxN%!z+7(B%mLa6j7uxggumTz(F@nAPWeLpOA%9!U4mooFTUX zK)&rRaOzb<96lkkWU_}IIT!PV=K$(N&dH`AM6CLx27TVEaa+30ZQuerBG>dJWH8RX3nIj*8#teS(^tJR@_$3=Z)@9p z)arULc!?l>nlN}vILR)UqXi((rt$~B1K zlG1NvK`jJp`gmFLFJg`~P}zU_643SKU0^GJo{JES3nc~JI4ji)mNxnvq!lo&4Cf3C zFfUk^{>OsSH@PS;md@p?tafUxSKG%!Qlr8AP?t(Hx4M5^8 z&Pv|Xv7YkA4uELb9UO=DjQ~Q&j;q0K9FeZWvVu7fs8@%JO|^@=J&wJ@U) z=3KA(sJP^~8I~W&+;K!eEm1!we_!@b6t>u&FEV^VMZmr?UGzf5<~?9Ry^^pTi91Ze zV0(UnAw8<|U3m<=1xd|Fadtz){f(D{I!l_rJVhrwF7@kMo~2ulp`5bD0ZfSP4|G|zJ)(31PjLsMc{C#e|cgFE)!WFY_9}ILAl+Z z_4ySKHGg7qcybDJ2cBB$baSzv)h5KKWI?e0;3FRkXy5-xMzq>LXuuo<{R_NklaNv3 zmKCUyH6}k-!iWIWSuR~kwJa&lDaO(%Ap))Kz*rY9q;5k)%wcXWzV62R^!GbvvL^&1 zQwKi1_$2eft-B1`_WTS^GjvKy?eF|H!)%2I8Z)kZ>;t1LE&KXIa@~MGy5XNT43R5N zhES`t=bw->$8;ghsL;lU=%aI(pE>CkOkRFN>PAs1uhK;T!49B&#F@hDWpl~vAX5?4 z-DdDgx%p)6cVPb!aHlY9srN&_k#D~0ZM|#f#qaFmop2Kcw0ZO6x6w2E~^mg z8mzK1NbD~cq+znB_iKQIUJVuXA+4s4>;aptbn$vlrkHgP7xpieWqi1Bho+G0w!yC2 zCuUzHg{&Zg@)b(kr1kpdqpcU5pt`w2`Ih258nT^`rYa?GSQ2!iJ5e-%bPsWxb9HwF zR}ONoXevcV>5zTupDJ+ARxI+j6f-Kwxiur+v&MY^Qq=($IiK@Zv&s7v}N zT?jN!WMcjB7;PRewl(C^aKG!E^jJH}9j)i$505ids=%EQWcoQ}*@m=jY|8Z;k~;D` zapGyu3j|Q6eJVkX7>+DF5^zH>)b*_Sv8DO?>uU z`5;h@T7$?z?*C-0v|KQ0PxIpW%s)oFCZMk(=kj6CNFOc zG4gXF7=+%>C+X&%q>*IO|*3M~?uN|?C+1w_Lqa5XClNZ0g0 zCH~E%Wrw88@^c9Bp%hd5Lkr!8>`osH(Qv$o%~?&T8!B<&xo{4p1@am~jw32q6<&7nD?dq* zmeK-8Y)8$^uT>?{e@CUmI4Ks9f7(Sj*nD*{!S(`h1Ozk%9U*R(IJ&xlk(NXC7xR`8 z12(2|PKa7&JvbRGGHil=gDn5HQj@C%ZQx1x(9#Pah+T@e;WJQr%y-@Br*fIUT36Fz zzn2*6xU(^1}R6?YjQ+-k|st)pez#$?H%Y^#|zKOYq&p_I|gV-+W3wdDwWF z?*URl7P~3femU>>f1ncwNfKS-Tx2EarB}Xyq@UD?#3b5bjKOt|cyT|Yf&qdHwk=JjH=K2~?y9a`7)+%0}TnES8Pix7t38id-$5GLponNt@E=Gf0q znw%>h2;}27$q)IZZlgByhY(R+K`-SDeB!l|`HS|Iq*$_|=oFm`mr<6>)l@=?e!A^9zC z8Y>Qp1?M_5x_M^MIt{uHa}!V5w}a+9*p4FdJ;<;+1xw%Wm!JVKsN6y|0%+Ih3qh0j zCC31l5|Z#cy)*n5$y$H#+p^gFNcX#GdL5m5TUfe2?LExJ#gq^J*aN&Tb9+> zhwbQ5pUqHwgzJHNoMEpT$wVh@_YT*2pbv6GO?opypfeZiAt^QBm9Ilz3>x}ZzGDSF zIR)h$k&|_ZY;$u5)U^=>k6m6PJ}pp2KX7b|11udiu8OAh=l4fu%eQ?L0Z@}Ox4o(+Zesc z{djbqIGbhKfpGFKMl_`|+cuTqa&c5NT6t>8pGS3tA^LkU#|Ao@n;#}O=GN`IE_j}H z&RX2eJui;-GJjtbA7c$4xjpmGjd@IYY#e+o_D+e6YV|$9^Wt0Ca95o;b>~X(Zl%mF zpDN1cf%0}%tZbR_*o+k5#4qJsL~#EMPOUy}T#U-BXQ-ynEI%=Se>1q?*<|g>lWSku zDQZhmY`j(%{9OHdNj~*9z4_5#Kvn%!hpGKGK5kf-F&M`8bm%?iyQSsL=!Nh7$Jbl` z8WnaXx{*Sigt2($_>2U5yV2$lMoLyW0jWsMLKi-RR%NxpjmoH{JB9RzC#TMzQ(Uw( zp3?-}NK{wrHvE!l^NI7W>S+ebsAo)Z{2525bsZY6+9xd8GFF@J2&s&l@b0&dB(2(X zN-L+@ojK{NaPJ#q%{HMm{kO^QFXr;2uJcTX3G*F|oEcatQKLz|K7FzHG-*QN$)=G> z_8P03(QoLuBSjdDh)QH8{*DO`PnAbe=@o_5b9x&Wbw3mB4)$iErBtiVbo3Vr9uBtD zLXPcH=v$ItV)>GXt1HlPtroKBB`)ciLTZ+@@8)tb1}Brt(Zwm}X!#w3qfGk*3YqVx z_By;5RdAf29`dK)!>BJ+mZ=XN%FMSLI?ho(nPa6y?(g#vd_8?25OoqYaK0B0Q1`B< z2Rne9%iZpFdkwfc#vZzsm_la4YCH^i(oW)P)`m4xO_8E*vGM6XGrDycc^>r%KF&S( zZvGPBfBkH-M&$GO&zmn;iwk-dN|C?CHfT%r?qu=f`QEMTMX9#IqfP8*O%28`RfafH z{M`dvx;V7m0E@-L-+Q{SoXKHOG}1J2KpZ4zQ(oPSy($aA#@mxGV!F^vCP8n&k;4A| zWh4j+mx;se+8Hur&i1CEov3`4uvGM~W8J?6xfMSqT3m6*mx7I#pOFYKI!;G0Yp8Yv z-uc!VKhiuXIhZ_3JHOac{vOvLN!jy}{Az*WI@+74P04zkImAwwnllgIU+huj^y?_s zEiCbTe|hpP%gt|XH?ttqTeLQslJ#EuhfiCgX)0<0$KLFuPu_z{yk}vDuYt<uPLd%9yQcjIO`PjUGQu5ZtTc(wUHX z;5XKG{%RxY4^WnJz~wgmXk9)U)Fwq#h0k9U;9-nYe7JsGpq3-~ta0t6COL`5#OUXJ z)zj4Bas=bMrHUf(w!8oROSdEcNAJ!4b$$wp9!_WxX8)U_fPTlvh{03C)Z2u?<1)U% zWA8ths3eBWl*J-lXOq0MOG{BFF0)Z=3g=#~VdeliOL>{b-SpMWm@9=!N7=!ueXV#9 zm3{2RKFRFY9mP>5^BZRgs?|h$m$dQ6uTlOU$O`BedkH_D=#L(k*OzZs%A06>pNWDxJ2JUnkNvxksbrxU|`6__Y~9fhw4#V+n;A2|K}sXfU~x@}@I3@Lym z&7dCsK+$06IK3@i5%@7I))NJ;c|@Ah`WDU@%to@3u`77b+YX~_+Gjb~Yz(Q!4gQ!^ zLa!}fu6!@BZE9$Ymzzk}a5G@_&^ryPHGf~H&9q-|A6yc{Tqa5UvpHSOg`a6@OElGu z&^&>c9}=>y&*f7`m2GqTx{~G~Or@_eeyMK8gRCh#XTiQDwVug!oBoVbr;*}; z=j-Sj|At`uE!k`RNr$U3qp@}2j{OP!{on6)dw9M?IBWi@2gYoF z4wzE%)Rf`s8SRItp~!1=+&lay_!>)CS=Je=p>cBS0`B-;qIGA($bC8uWe0dZ&HQ#T zi8l#rx0n1Fd>Z{sOXfLf%HQ8BoM|G>^Col_%@&l*CS8!}SCty;ldCrP{$F9=8P>!W zwHriGkfH)g6&2~dqewdlNRi$<(rb_+Ef567BT}SLuk@MJJLdv-h-4NAVfN$ z<(qiU{r=qNK6m|qXZFmjz1F)|+k5t8uw-Nd{Ud_xwt(ukTFuPE$;tQUobpA z1-_V{)Wih-vi(3smJq}5zc2{#&~l$C(lJMm>d3I5pS@|(*%v6#MyNpe93^@AHn{}b zc^&N2MtTv=kv+|jN%M+2{zmH?^=}LY)I&ZPj5-R8cx%@`5IoD7J~nKD2T&KIxq@Pw zOv-hRbpy2R23>;YJ>4B2Wq1KWrAK4Kt2EQpHRm={w=DiMrl%Sv|6+b+6rr6UnFY#K=*UX3qydJ#tmd{8L0Er)G?nZVDW}n|6Nv za71mAPbmT3=|bxzozy}f1)ijbH79pgowX@!zY23FkU~#Rx5X-h2l>^Txq}=Q-K7T& zUEik5l8q%L3H=>&Cxvr`^j++E=*NClCH@@C&*IxGYQgGCJZT#+0!g8ukS46)qKS8H zYJz9erweQh;Y0Z2YiC=pmQobtWP(p->*!VUjVSF8VjRI`9ugSihXU4?rzfMb>|r~L zw4p!8fH1T(`290mlB#!O_`Sekx;fgG^$*bBXV4Xe3-^Z4_|5I?3~%enZVmUTg3m_3 zN4l?yA$;|b33pSjc|XKU^l94ByXunLO31^&WesHMN1os(o|1(P)k}I@Jn9`*dxu-) z)ULBZa3DIU`$od(#CP+O-|f|9Y%)qo_xJG1C-DxVp3ZcZOw1$o%6BHT5CcJu#kC?} zNreEZCoi+>H5{&P1C@dZH;e;6n~}aaJ->=TG|fY%OTCKC=EnN<;rfh;9$!bRRrkvZ ziv8^641CQ=f>|>p^?AkktVEatMQbI+c4rm+8{Z_k+0D3lRr@b^U_;aj$}0qE5Z|H` z1oizI&EW18$4?(sLR)6{88P$n#2a`$wZE%z1x3HWef@_NA+^ za>;}3aEc|vd%a^1Ni-c+GbHCm8-bRBryswB0h#ew!pz=~k7;n2NpQ$QP}l-CWWH>d z(mRFuWsP*u=+dA|-gBTByPQ$CK#0VYy63)pLhJ9z!;%f}eA)WOj>pRMh6KhQUaC0y z7d>n9Q;A1?*qQf{=QW&ZqwlI=;iBa)c&?qQeYryB)ahfrQ)2I0Jn3KavbNT?t|^&d zQ8sLi@)(T|WjY7-6Zf2)qih90u$2e%|zbEPKnW`SYBO)I0ckdw-m{USoY z!qdqld%j-Fdr4~d!UBIa%;KPXyCrDkutY#T)M=%$vQ2ho@zfM0>#P#J7ah3>m<1J1 zqN-Xeb;?ve!JnH1RHe^b>r-qH9Nhy#AQOxWP6bOpf?~tTeZ(f4kp9E@r1HuorXYYf4A`%1hL$ zE1CLx+q7x)72Y{les0lm|1nh#81LR<{Ac0yBTc(nIB(P7)u49ibnuOn#T3pxv%^3p zba(HxOdBdHph9PNd9=qwsBJ4PMB(5fJ7_NCo*gL-uaks>$UTC^b(_oT}5-u@||KXuWfk@%#*0$ z6w9nr1=b3}eX|gCpZ80V$JTYNp4;0Vu69Fyi_Zo%r7TlEIJY$XT`jg7t@U+e_s3q| z_femm_EcrybFt<|cgnEqO&<5n3OKPv$rN`TmM7ezw;-q9tyEj3sRpU%&Mi zzM{F}q8)Sk4Ffql%Wis=>D+VhsqyK9clQu1JNxX|>%*@YHf_uGKO z&S*>XY4NaBKL7E{J@A+=N);AOPxfZhzc}FuLfhQDs>Dz5@YWiMdqhg)K8k^g8A+(s z3riB5Ngm#eWMi*c z2%++ArdN&EmjMb)DTK!nqFI;qDqQF9k2olS{Z!)Y+aMTqU^CPt2m;w^L_`<3SuA}w z=jCG&e2$!ZlWDHB9+cnc19#lz{v@hz8`Hn9Zz|?9gbvCV5h+P_{w+P5NUzZ?8)Tvo z_B+4sm!Z-uFimg=d_qe^A@Bngj@;(bizAJvSK4ggbnQRh<-QJ^=C!b4+ML*2X zS!Iwe&qSN>Jj=S2SKqVdLYo)eTRkr~oE0B*FBp!j7VF4_eCj*kyYM|b(O+!ab`GFf z=&rexx7&j6N|$nYqI{fBMh`wb84}OkFs= zp6u1M`x+H@!6s=ZU-4L9!C`}q_F{AaM`&lihwBsdB!b9ID9=7WpNeQ_qZVSZU$c50 zJlS>y6rKrKJ2IIusA1;Fo1Rf+Ulpc=K42PazVmyWT0ZcDa=r}fP5{@ptDJomYb-7J zBirB4hna-?B}f~wf_?ZSg|RcpMsa}HYya@$YKGL^`jDB}dR5c3(Gsn$UOY9DJYLMr zF(fFBrem>s56@_`tI^YrJWgXiw2~~5H8=mM%h#!iRF$$!%p2n5>2`xA)swVkb7jIk z1Z>(SC9fMq$7n>(KiV(0L<-T(3yME~T_5n!Wy3jrm=7ZWRr@0tW@-n>ff_!duDU0?V+o2K0?XiG3z{cbQ zpFUvE;7u~xA4+d|eOhyrJx%Vseg^Aw!E(0nyn7>bT`1e3yZ@>q9{Y9^M?z-UxaDOP zh&ywLN$>?GmbGj(7g_My%K^Ca$P*BwN;Z?9Y2xmFknOAF`(LWXen3!W(QLK#7)GbV zPMP%u9>Gi!Q+fnin%PV!o9!wJ9jf; zLelD_{g|I804i8o*;sxMk0^ek8-;-sZT2VNY z4!O4Pj9S%rscP7(VvBSsSH9S_;kZ8WmSfEVD;{9J z@~(&nt-L>NAwxVz_y%lvLU+0SEEpOI-WPL zyj%us_dXoD`aYY#yyARspPf+Ny*R-S^(3rIStpCHfZ;r4y}B*Zxit#MAIgH4$bL2YUT4;3124X;rrh*PYq2!FNC1>?Gqhl#d}(YYiq&`Hq9tGKIPTTBzOL{*5^93 z;2epicGO&d6qHuRJH^_9J>Im}+4>%T;cq0=TDK*74Eb$i)PgL5UltMcLco?RsL-Nx zmg4ST&*%})Zs~pn?f+h(&;GT_a`1Xfv(+JQZL%<8;q#*;a9MmCeUzx!_jGzT`2hSp z-UfPtA<$lCyl*26w>(*-d&vwSDFP-eU8`t4XuHT)ZisE6K-}-IVWX5$xKddD`l7^3 zexKWI=V(!j1f)&FF=HByeXmJF#gE5Pd$N*7fB(!OFzmX)7SCsGxe=^onPzexhmKxv zcFv%w2#+iR)((H$2V=mLgsU6))qqSu@^Ol45 z)!E4p)rm~CPhVJ5=Idc#dU-Ox2|t*s|Z=1>$|z2JNAeG|8D z-_Eq9lL@Js*IHW1mzrT>xnbEQgk^TKX-;~4(OdXF+Tuwo5TZVbeX|zGDsA5VgRxG7Q=Mx#g}n;n zX&g`&a47k0eaG1JN#@~ptI5h_lx0osCd(8|a&9YCxoP2UaL7`5hViE$LMWF#6PaJL zM~uW7i!f=731pJ*UG+pAK>``nSoawrf_z$)xf3`0dnYDATB%fkT$?TeExvdDQ8*PH z|I~byiCXu$1?IF6b#6mQe8iD7v6^V%*(1@=P>2x$6=|RhMQA-vy9I-wQ4zPpGR+*i zgasFxPoq&s0hi)(2e^yO#l0Ww+kpe!zBUuSgl*yCT`WtFyGd>&dIf8)5-R!fLkwBp z+r7cVH{kj*==P1%WhiiCyn2Jwd$%5$*30I$@~v!wC1z!GGtm77O+Gyn*^LDaJD^-> z?2wYrj22BctwoX49Q)7R*shpI6627hg!-CLrvsg z7`FNQ9=y(?=-J|kQnO`Jk>1ArqtpdefFLvAoj;8lm1bfJDWkKv)VbxE=x>FoA z)|4{^9VFC9eBoyWAo9s<-y>ze_^E(8RfE=sZ0WQem7XcoNF{eN;62n( zT|3L|t_c(FCDuWL1cgDjo+Te?`BHWDPd2(Qj;TrXEV-^Dl%xV@;S)VonXJyEZw4Ic zgw#o|!6TCv+U9A##y$28`WsZ^UO3wvtWpU*YN$H{1i??3pz=3MFT}N*8;X9Kp_4{W zGiWC|?|CCVuJ8)0)X|J4eJ*hy|}SeNh#@x>G@25@uuJU`Y`{H?Tlmf01dlo zCSV1|cmDPbF4`wl)A5CM=|G|pY(4MO`PnT#%pNRIy6w7xuPm(&GjQHNlaIcTf0@W~ z!8V|=9;)=6t<_6=s}TLh_xJ*)g=!2bqE{{AVg?r7R}mswmHLd$<;-ZhQ?K+K`^NgZ zo_hqH9XtwmHtCY`2tA5_f_Q0VWp>+Pkxlc3IQXx$(P&6MZ>;E7kNoFrzWkIL z0rGrik}#c3&z|%~BQh%~9^Tv8JG^rX3FkkWUk#~gl$%(Z=`$XG&5$Oks1|Af3Q=D= zVgA%M=MvAyz0R@cbw2MgxbwQip0WvXV zT=?KKv28=u=!f5Y-H{y!+;1wXA2c)|@=3|)1bIzU51lv$KJ$mZ9%oV6EQL+)^e z+M1cehLRV*gLy%R{zp~Hx+!Z$P9}uMcGXhZD@4;LOVeV!B2>N3-DdODWB-_Hgpgs{ zv8 z!%#fgwv}vCVh6u<488E8+|s_5vHbhZOlp_BZ}y=T5OdE#a9m8#6O?r1=D6Cg%2UQX zS~)*9AC7Y7SAE9vadLYzvO8OoI`tNC@V&+aU@qA|YuE-=^UnaU?(hCM9elMZk1_px z3h8ow;TY1aAMCL9L9hYKm_I-k3+w?I1Jf={H;YFxpES-!v;gkAhYB)4&3tM}mbxM- zRikY4T^1n%{Nz}Id%v?0KEHA*xy&+bN<5zMjvYUimdR?b#)9k`*g|Fi2`D_Y;& zY($wbq$UwCJiDDOxp3=2nRf{;j2N+r5|aN-h!w(o$jz7jfMF zJA$~+>T{cwQ1cmWtHlP|oZuJsTD66H7V>-+=3B4Ef2K>zSFU2$=fc8#$9Q9n5879t zN=mK}rT0n*S&ZRIf03VG)or0RO+*OPWpjIGojIeV?UDlD{e#NS0;LH!<=1id8DrWF z?H9rq!`b6UfTh;nmhm{;iwypaIiHF;Wix5bJKf6mu)un*vm0)p*iCMxIMUFdJ>bRf z+-d3zzfb#24VuUJx$OOjO#-SxWCdmr0({6CwIvsAoXz-^4PO~0CY7>_cNmbAHVio= zB$l>4p5LeP?{_p>JhexzX_jZpJjSp-q-*_HTR02DB$T#>oj|@v_rvA+WTjCV+kNGg zC3q}*{l(KK$JXEOD#%2MoAyODX!3t81%501k&;7E>CHF}%Db4L^&n35fYaKC zE-ky)G^A0JyVc&i4`4f6mgFusy>RAXv5$SaO6NkvGmY85Q@#y?KM(soC>JY;8LBw0 z_#Wo_5;QY}1_q=6*12IZo8=`qQMJSH*dURLF=JO>azp-d`D?7Q=O76hkz}x`87~h|wmVM(1cV84` zMC8TXr;AvMJs9^juNJDag~Wo@?)3>v!tyq%F}OSzt`KD4x~-_jCWu9pH|=W6&!kQt zvO1G?tTFNX*qSA3-TYEpU$EB*lU48-Ks#(p`e?Y{h@Lc_4YQUoD}P`TyT<&UKyL7= zNoKt^u-fMYmsRDk?~cUIMZ;%p#sce}0>-_@QVgjpC=2`QIT>V?DsJB79_F;|JCUew zMqOhDle8{09G!1;OdIWgHtU$qkVZ2zj;>C^z8thNO=J_b4Q6%y%Cr5}?S|0sxj1&U z)DeIBV`?BpGkRFCUsXA|T_%S~1$hfDqopch!h9N%1Z!9gu*d)U{m=9>S+Tx#1|g`T z-Wp0d9#6B7F`PK*^G%7xVhG*mXJ@{zP$Xc3U)4y2OyRJoK!5Gss?hh<0Z6|Xn2uOu zd7`DO55|a21?Y&kOrU=o4B8s2|A4E4Fr&9q)|T^Sv*3pEZI3LhA5ZSHJ4g!8xjVjb16HxX*aLe%O7&1mwu2j&$H)GUVy`PKj>&HnxWkTqSK}{?9nia9St-?~Yk!FK} zJ<6zOx|)ya%&>*)?9cAY-kCgriYvM<5ckzwc zK~O%|c4sjmTS1s%!aPXKgFX0nfEq+$bTskYx_G4aZXIQ1c+!64W!!)>$obww$ zocr~TwO0Lo1RFMv-*=^1DCR!(-PIDit^HT)vh3wrP}Gkx#R_I#S>*Sky5cgZvE9b2 zcQ3m{pD+%WUetO)a|xtc%X<|t~& zo4%u6H8a_eyyI8FYi5`$X>N9%K?h%#_$Yfa*~lhAM^-q0=UWg*V_|xoyHDTIRr9HZ z&ddpY&g92KT+(z)qv^<2e!Q*A?7DXSM41(vkS=+q7^*SX?ihj#%%H~TpEV*L>zm3{11opL1I%}=Z5pB(R!qGkI_OjZ|iG>^Eu zq#KeaD&mS*XWtyFnx!~H#WYjpFuCmBX~HoARxtpt;{_}IcS z#cgYHt7N+(05V^c;ZwJ@r|i@g7YUx%pZuzK5|UQAOOud=e84OvT zbPhm7_3Xk=t#4wur120!h#UqroUu*VoN@ca_6cg@xE6x+fOGwbG3o&+N)!vp&_n1SRW&kSx6iBgC#$palqvdxe zzMh`>sBOu!Cspg)4oY}|ZLfESFyYolOA@7l$MA!IjOvlT<(Go)tCFqU{^<+2FPEEy z1-a=6gPv_Gy^A`Gyf`i>A5~fj-8E?1%NklU8Xa6WY`c6fu0HQFe;SeAaEYK9zBSy7 zZIn+!c6&=(x42&n{Vs*3&kdIb9oG1m9m|nxRq@bO)^8#LJi;N!$2H98GYx)p@M`7d zd+2dB`^En7VC@4LsY$AA+hYZM;Ni^u)JxAkFQBZ$NlsKk+{$!V%AZ!)=0abTmYqhY zTWzMYt&T>Guk5@=9%drV2`tX9e~^6RZ*>=!28^bDfADjU!(pivyXLXA!9_prz!R;+ zC0{v;FKWi*CMN@G`L;sYWY^Q>gk?4+YxWNFBO8T|%RCB3XAQ*Uq(c4r>Jtxz8^A5z zKT`!A2d!eC=!y>YHKvc2uRp>Vwj3RRScD&QHlQAw$TsO|z2^v_^0Km5j&*OF3Vpvg z7fVH-9imYWsor`Zzo6%{#lJV$AtlsLD#K)msM(v| zfOwdTw5L@- z&Ab|5WR9c@Gm0BO`^1=Ji+;|JA-})G)B}=@8{a({@@;%--)JAnB6kM&+kf0>e)gi+ zWqW~=5B}u5J8Ru@{yYzv1z)Y%Ts^iN-qct;ze{PtZc=;TGHjnTr~sP_t;6{?b(imi znlu%y4l1PlvSlHgX>4Z54vAOoKlY|>?9R|wJehA_XZiBt2JMhX@v+j((Tx)J>q~Qc zK`QH?QC7$P#y})_-`&K;!~f(s*<-#{>mAr*HT0R(Gda!dKIu8IEn{|{b4Y(Zsv;Qq z{q#qIeI76!$IMw5F7r$oA}<{qNs#7N@d65%uese5IsrDXTQNc`055q!kbTb8EH?sc zWWa~<>HZ#xjEf$LYw!5uc{8CoXTBjt*i-o0=9HS3P5rU?anI(IA+$A=#&I3T?t)72 zl7ka2tO~Y9dg=C|dX zhF7Rr|LL`f;MlF2)~P2bXSFn!MjV8r)QZi;D@Agv$=Ox8+COo&4ZJA1x@BV2cGP^) zM(F0V4hgQptIk4E2}U-qb0*72_I3QEC}Yj&sn5(VT}#+glf4Pqg|CLFnNZ7=ZHV&W zy?A!lw7j|^`hmk)R*7t9pkmc;x>yb$mSr|+6PofoOr~(mH)6V5>h4)8kf760WI@@b z$z`3~*;SVvTNiydrB~t!*>xfNGNgm%%&EA2sI~zrBxecfKCdqp|)}@;;8m51;l*yz7_|1chuK3dm zoq6bNO#1r74%#=AXM5n%S6lO7+z#W=$X37gIUiYJw*3NG4e4vsSEv4=gx}kIJZ&(m z+jQuUUlH<6ew5w6-6AoPPD)pKNG;?%0f%|93Fr4aPn?st=U65!i8*yQMQ}$A2r~zED(<+A&!*$YkdU4oaC~%xDW9S@{-^W6 zkir+2?c&AeBkeapatOZv(=(6r9XkHGTm)KZ!N_;zaj{y;OqJzDta50a!tV!^e8-yZ zxRg^e_$tf`YA~~i?s3;_;*eHUu;0$?M7&3gHa^X?n}5T3u<`@OJ9p7NVsSFFr&6ru zZRVp9fGYQB2pH}CVu|F1*Is+cQH+ChO;j9FJ2{3_^2}{1v@yN?FiCzxh`XWtj^)lE ze`%PSlsO~M*Rt9|kFzbGGihhlRc7gHO`>$kxD=b9mURe+y9dp=d6rG$6S5R=1Alox zwMdi{CA|=;<`}}Ene3&YFoK!+=w61Fq)FNPIiHZRNA?XJuTFXuUbBEJX}sv{_3U?> zis}uNro40S7o8<)zh!VGj#JfP#fS`+NN)pAxAM7Z^)TB=jZZYFrJIR26HZasRxMW; zxg-`YDl4NdWA)K3OB#u#64<^10&z#XlDUR<9KHV8>#Sc7)y#Os;C+<2h+h_X$B)UM zwn?P8WLM9MM9a_gyC?4>?FWFB3^6XtRgoE%crxStZTR3zc=Le5-&sj-Z zWFkJ|E=(@*XTVQFT=tdCz1hA0l?p_si2rj>`#*uj?zS_Wdws^h+AQ!Ar#+rNSAZO( zrPM&>Ok@h`=F(gpD}k7o0p(q5uO)dn?*_dsS3dCYc_4AudeNJX6{LM5+Y4P3qB7Tl zyP4hOGU?fV@~M$3$M*aUv?zPOaGM=?P%XiPb3C763?TtI;kxf$t`1-BVlG1nJ3MV? zz$&DOs}N%Z`cHpX20-D((;@q(!(hn8Oi@M4$#(8aBAh)a`J++CO-piJTW9`{LD@;G z!_yc*g=jm4k7*uGpl_-KKg#p-GM4b&9IRM4-SX1X8zT{bE=6N1CNlqY763M_7M^RAb?W?-Y8_5fRKq5lPXprvH1I_kY z0E8v_AKL!X$-{skNzb^%!0V(vark_1n0&d`XqbMH!($4F;*6j{QkTWQt z?3zkD0B;N(r#OiIhOe^i{1<=`m7R|`rJEEfD17B5J$a7lPgwY?2fj@0OkG)T_xE0m)bw?|%*ZQNqfiuo5j^ZFKxWb;zlE-~tCQx^r57QWyshtEAPBVQ@+wM_? zWN^L)Ae_oW&HyM;qY4;BjZzv_W?1q!z~t`N+yP{}4h*Yp(@$UTrUc-fNCRcy4=DVh zjHOWIE2eODd!fI_J`MmZD1>)x0oVram<@mm;~Vd5-v!VVF`(ij!n5?t4!G{kk{D=! zHK2mz|Fk5+Wy}B^h(|f``5A;D<<}3w)n{AB%qj|wpD3>$@Jw|l1IlQ8UNhQ8o7%StO2zCC{O+kFjit?xaj?M zDqG}Fd)=o*4e4SX^?_CuB)e^)A$fS8%OJ_dOWm6Q=cV!cBY+sX^d6w=AekG);VHU} zMgSK_zfA7)rAHjVU<|SLI}-1t$RGeuoA>~*yq)xf00eXX?sXyuWzquzg8ugTBR0s^ zl&Gzs^;N(>0cy`73M3Qp-`N}mz`j9ppZfjhB6cR?ggT5L0ALT#d(3Q0w0dt=Ac%mt929y1nZon(0Q+B(xlU|~>7xXJ z6u;jB+%qNu7^-kynI~p;curzt6`uV+RmHtUrU(8Z1JH2!GDrntyb44Vka+iPB8YkU z9^{}L;Assg{EF>95SakdW(H6OQNH~TkxY7G_mt5<6eLn~44_fY5>YvTbe|E`BE?K6slj)2G4DCp&K0j{c;z(yq!(lt#D(&ivy%S}H+44i;@-%bO%rHcUp z7qzP^-Vq07YX1jb`#5WPk5&~ENLz>~3y78O@c|H6;syzzCE`Ojz_rPTSRU(O0awcx zS)_9y52yS4kFDDKNdV!64loCD6~F`kv-#BfNC0j|YCuZh3zkI7&@wFoi8BGA_Mis~ z1?hVH>DVbe9FV1phzb1-B1->~GI3l$IrqsIs6L$oD9|{F`r2I$PkTTVL|2zh(|I6= zjd5*`s3L$D@1D#*8(mg z10oRs+g|{L-jlan$is=b4HyfZEDh(IKs?K2xSCFqBkM+#(bi?$4QNprcOnn(`opOG zIdOQ0^74Tsl}3{3_y;k7UrcYHj;eUL_{aZ@x?L17J?}fWh^*Vk1NF2?LEga$->8<# za{m~1;f_oA3^Ug<;LBZs*%&>taDzC&*Z-yVk$?LdNciJxnNR;Ht1Ckc<)HB8e4tDK ztT6rs=+7aLi#XD;SHUB`X%FJEQp{>yM?zG`z;LFYnFf%-0g?4IY>3(FFr;HqIY;DY zGr6;*TSgOEYER;Xhbnk#mBD{ra$vW|Xnbqfc3ph3*I6aFoaUZv)@y1hnigNbT~z$H z3&@K)D^i=t!ucYa!(G0`uVDl+?E9u}_DD7fdc&3}w}TZm!_`+)werG>>{sEUwZ!Qp z7MDGX@7!A;WxFfT^1>H107(#Ejll7PTPL-VsrG{KQ1wXCUA+QcL zqgW3y!6`2r!EhH}THLjY)qRma=I^VO`0a);l*`NSN~tHt=*di-`PwgY0@pmidpxO} zKvfNg@Tep9aVE8pAj#X z3fak5f#K2?Azj3s_jWn<`TOj;U(YKj8h+BqE(Hi!qsnaC!@O7{_VC47H+}-)H|h?+ z{ppufE|y9v2~Y-?1?s-V=f!W1x>DAOY~CQL7hF8NmJsjB!Jj-|=8F~$W_fF>JKyD@ zjN$Yy!AY#PlQFUM0#9|zh}-C z{&~IOS6qJV9Y;7jP_@s_n09o|IW0uT?Om<75(_rh+Q{rA@p2(8q9)c)|B^DXZuyrO zng94Y@t}R=OC!Y1tdBJyl7SMF2#8v{dG5%pljLv+^RlnF7T2;?(CSb>o-RXe+Qo?Slo6b z9rGO1yzM3j9}lEBEnLyMd8=!z*EDVEq=R0VS5to*b=ti<_x1x2PY-N4)W4TmyrC-& zd98x9GD2Eqy|e)Mgpu)Z+ZDbY8y__QjHj2c=@swpclaWXUA!Q zhBbTl^V0wJBSS16{w1o|{{kN|X#SU~fHVKE!TA4YfIpG*5AXkrwalB(&|MYrEuc^a zXh@2fH!>B0iON62P1M9D5wGDk#fO9HFI$|wfHL3@F%A)Eb(b7fALIya5gXK1w4YV{ HWgGE7+wtnM literal 0 HcmV?d00001 diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/project.ewp b/bsp/mm32/mm32f3270-100ask-pitaya/project.ewp new file mode 100644 index 0000000000..657908cc36 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/project.ewp @@ -0,0 +1,2317 @@ + + 3 + + Debug + + ARM + + 1 + + General + 3 + + 31 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ICCARM + 2 + + 35 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AARM + 2 + + 10 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + OBJCOPY + 0 + + 1 + 1 + 1 + + + + + + + + + CUSTOM + 3 + + + + 0 + + + + BICOMP + 0 + + + + BUILDACTION + 1 + + + + + + + ILINK + 0 + + 22 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + IARCHIVE + 0 + + 0 + 1 + 1 + + + + + + + BILINK + 0 + + + + + Release + + ARM + + 0 + + General + 3 + + 31 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ICCARM + 2 + + 35 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AARM + 2 + + 10 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + OBJCOPY + 0 + + 1 + 1 + 0 + + + + + + + + + CUSTOM + 3 + + + + 0 + + + + BICOMP + 0 + + + + BUILDACTION + 1 + + + + + + + ILINK + 0 + + 22 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + IARCHIVE + 0 + + 0 + 1 + 0 + + + + + + + BILINK + 0 + + + + + Applications + + $PROJ_DIR$\applications\main.c + + + + Compiler + + $PROJ_DIR$\..\..\..\components\libc\compilers\common\cctype.c + + + $PROJ_DIR$\..\..\..\components\libc\compilers\common\cstdio.c + + + $PROJ_DIR$\..\..\..\components\libc\compilers\common\cstdlib.c + + + $PROJ_DIR$\..\..\..\components\libc\compilers\common\cstring.c + + + $PROJ_DIR$\..\..\..\components\libc\compilers\common\ctime.c + + + $PROJ_DIR$\..\..\..\components\libc\compilers\common\cwchar.c + + + + CPU + + $PROJ_DIR$\..\..\..\libcpu\arm\common\backtrace.c + + + $PROJ_DIR$\..\..\..\libcpu\arm\common\div0.c + + + $PROJ_DIR$\..\..\..\libcpu\arm\common\showmem.c + + + $PROJ_DIR$\..\..\..\libcpu\arm\cortex-m3\cpuport.c + + + + DeviceDrivers + + $PROJ_DIR$\..\..\..\components\drivers\ipc\completion.c + + + $PROJ_DIR$\..\..\..\components\drivers\ipc\dataqueue.c + + + $PROJ_DIR$\..\..\..\components\drivers\ipc\pipe.c + + + $PROJ_DIR$\..\..\..\components\drivers\ipc\ringblk_buf.c + + + $PROJ_DIR$\..\..\..\components\drivers\ipc\ringbuffer.c + + + $PROJ_DIR$\..\..\..\components\drivers\ipc\waitqueue.c + + + $PROJ_DIR$\..\..\..\components\drivers\ipc\workqueue.c + + + $PROJ_DIR$\..\..\..\components\drivers\misc\pin.c + + + $PROJ_DIR$\..\..\..\components\drivers\serial\serial.c + + + + Drivers + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\CMSIS\Device\MM32\MM32F3277\Source\Templates\iar\startup_mm32f3270.s + + + $PROJ_DIR$\board\board.c + + + $PROJ_DIR$\board\mm32f3277g8p_msp.c + + + $PROJ_DIR$\board\ports\user_key.c + + + $PROJ_DIR$\..\libraries\HAL_Drivers\drv_common.c + + + $PROJ_DIR$\..\libraries\HAL_Drivers\drv_gpio.c + + + $PROJ_DIR$\..\libraries\HAL_Drivers\drv_uart.c + + + + Filesystem + + $PROJ_DIR$\..\..\..\components\dfs\src\dfs_posix.c + + + $PROJ_DIR$\..\..\..\components\dfs\src\dfs_fs.c + + + $PROJ_DIR$\..\..\..\components\dfs\src\dfs.c + + + $PROJ_DIR$\..\..\..\components\dfs\src\dfs_file.c + + + + Finsh + + $PROJ_DIR$\..\..\..\components\finsh\shell.c + + + $PROJ_DIR$\..\..\..\components\finsh\msh.c + + + $PROJ_DIR$\..\..\..\components\finsh\msh_parse.c + + + $PROJ_DIR$\..\..\..\components\finsh\cmd.c + + + $PROJ_DIR$\..\..\..\components\finsh\msh_file.c + + + + Kernel + + $PROJ_DIR$\..\..\..\src\clock.c + + + $PROJ_DIR$\..\..\..\src\components.c + + + $PROJ_DIR$\..\..\..\src\device.c + + + $PROJ_DIR$\..\..\..\src\idle.c + + + $PROJ_DIR$\..\..\..\src\ipc.c + + + $PROJ_DIR$\..\..\..\src\irq.c + + + $PROJ_DIR$\..\..\..\src\kservice.c + + + $PROJ_DIR$\..\..\..\src\mem.c + + + $PROJ_DIR$\..\..\..\src\mempool.c + + + $PROJ_DIR$\..\..\..\src\object.c + + + $PROJ_DIR$\..\..\..\src\scheduler.c + + + $PROJ_DIR$\..\..\..\src\thread.c + + + $PROJ_DIR$\..\..\..\src\timer.c + + + + Libraries + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_syscfg.c + + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_exti.c + + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_gpio.c + + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\CMSIS\Device\MM32\MM32F3277\Source\Templates\system_mm32f3277g.c + + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_dma.c + + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_rcc.c + + + $PROJ_DIR$\..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_uart.c + + + + POSIX + + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/project.eww b/bsp/mm32/mm32f3270-100ask-pitaya/project.eww new file mode 100644 index 0000000000..c2cb02eb1e --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/project.eww @@ -0,0 +1,10 @@ + + + + + $WS_DIR$\project.ewp + + + + + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/project.uvoptx b/bsp/mm32/mm32f3270-100ask-pitaya/project.uvoptx new file mode 100644 index 0000000000..9e085f45b4 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/project.uvoptx @@ -0,0 +1,185 @@ + + + + 1.0 + +

    ### uVision Project, (C) Keil Software
    + + + *.c + *.s*; *.src; *.a* + *.obj; *.o + *.lib + *.txt; *.h; *.inc; *.md + *.plm + *.cpp + 0 + + + + 0 + 0 + + + + rt-thread + 0x4 + ARM-ADS + + 12000000 + + 1 + 1 + 0 + 1 + 0 + + + 1 + 65535 + 0 + 0 + 0 + + + 79 + 66 + 8 + .\Listings\ + + + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 0 + 0 + 0 + 0 + + + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 0 + + + 0 + 0 + 1 + + 255 + + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 0 + 0 + 1 + 0 + 0 + 3 + + + + + + + + + + + BIN\CMSIS_AGDI.dll + + + + 0 + CMSIS_AGDI + -X"Any" -UAny -O206 -S0 -C0 -P00000000 -N00("ARM CoreSight SW-DP") -D00(2BA01477) -L00(0) -TO65554 -TC10000000 -TT10000000 -TP20 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -FO15 -FD20000000 -FC1000 -FN1 -FF0MM32F3270_512.FLM -FS08000000 -FL080000 -FP0($$Device:MM32F3277G8P$Flash\MM32F3270_512.FLM) + + + 0 + UL2CM3 + UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0MM32F3270_512 -FS08000000 -FL080000 -FP0($$Device:MM32F3277G8P$Flash\MM32F3270_512.FLM)) + + + + + 0 + + + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + + + + 0 + 0 + 0 + + + + + + + + + + + + + Source Group 1 + 0 + 0 + 0 + 0 + + + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/project.uvprojx b/bsp/mm32/mm32f3270-100ask-pitaya/project.uvprojx new file mode 100644 index 0000000000..e631615e9a --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/project.uvprojx @@ -0,0 +1,836 @@ + + + 2.1 +
    ### uVision Project, (C) Keil Software
    + + + rt-thread + 0x4 + ARM-ADS + 5060960::V5.06 update 7 (build 960)::.\ARMCC + 0 + + + MM32F3277G8P + MindMotion + MindMotion.MM32F3270_DFP.1.0.5 + http://www.mindmotion.com.cn/Download/MDK_KEIL/ + IRAM(0x20000000,0x20000) IROM(0x08000000,0x80000) CPUTYPE("Cortex-M3") CLOCK(12000000) ELITTLE + + + UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0MM32F3270_512 -FS08000000 -FL080000 -FP0($$Device:MM32F3277G8P$Flash\MM32F3270_512.FLM)) + 0 + $$Device:MM32F3277G8P$Device\MM32F327x\Include\mm32_device.h + + + + + + + + + + $$Device:MM32F3277G8P$SVD\MM32F3270.svd + 0 + 0 + + + + + + + 0 + 0 + 0 + 0 + 1 + + .\Objects\ + rt-thread + 1 + 0 + 1 + 1 + 1 + .\Listings\ + 1 + 0 + 0 + + 0 + 0 + + + 0 + 0 + 0 + 0 + + + 0 + 0 + + + 0 + 0 + 0 + 0 + + + 1 + 0 + fromelf --bin !L --output rtthread.bin + + 0 + 0 + 0 + 0 + + 0 + + + + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 3 + + + 1 + + + SARMCM3.DLL + -REMAP + DCM.DLL + -pCM3 + SARMCM3.DLL + + TCM.DLL + -pCM3 + + + + 1 + 0 + 0 + 0 + 16 + + + + + 1 + 0 + 0 + 1 + 1 + 4096 + + 1 + BIN\UL2CM3.DLL + "" () + + + + + 0 + + + + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 0 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 0 + "Cortex-M3" + + 0 + 0 + 0 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 8 + 0 + 0 + 0 + 0 + 3 + 3 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 1 + 0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x20000000 + 0x20000 + + + 1 + 0x8000000 + 0x80000 + + + 0 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x8000000 + 0x80000 + + + 1 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x20000000 + 0x20000 + + + 0 + 0x0 + 0x0 + + + + + + 1 + 1 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 2 + 0 + 0 + 1 + 1 + 0 + 3 + 3 + 1 + 1 + 0 + 0 + 0 + + + __STDC_LIMIT_MACROS, USE_HAL_DRIVER, RT_USING_LIBC, __CLK_TCK=RT_TICK_PER_SECOND, __RTTHREAD__, MM32F3277G, RT_USING_ARM_LIBC + + ..\..\..\components\drivers\include;..\..\..\components\drivers\include;..\..\..\components\dfs\include;..\libraries\MM32F3270_HAL\CMSIS\Include;..\..\..\components\libc\compilers\common\include;..\..\..\components\finsh;.;..\..\..\include;board\ports;..\..\..\libcpu\arm\cortex-m3;..\..\..\components\libc\compilers\common\extension;..\..\..\components\drivers\include;..\..\..\components\libc\posix\io\stdio;..\libraries\MM32F3270_HAL\CMSIS\Device\MM32\MM32F3277\Include;..\..\..\components\libc\compilers\common\extension\fcntl\octal;..\libraries\HAL_Drivers\config;applications;..\..\..\components\libc\posix\io\poll;..\libraries\HAL_Drivers;board;..\..\..\components\libc\posix\ipc;..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Inc;..\..\..\libcpu\arm\common + + + + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + + + + + + + + + 0 + 0 + 0 + 0 + 1 + 0 + 0x08000000 + 0x20000000 + + .\board\linker_scripts\link.sct + + + + + + + + + + + Applications + + + main.c + 1 + applications\main.c + + + + + Compiler + + + syscall_mem.c + 1 + ..\..\..\components\libc\compilers\armlibc\syscall_mem.c + + + + + syscalls.c + 1 + ..\..\..\components\libc\compilers\armlibc\syscalls.c + + + + + cctype.c + 1 + ..\..\..\components\libc\compilers\common\cctype.c + + + + + cstdio.c + 1 + ..\..\..\components\libc\compilers\common\cstdio.c + + + + + cstdlib.c + 1 + ..\..\..\components\libc\compilers\common\cstdlib.c + + + + + cstring.c + 1 + ..\..\..\components\libc\compilers\common\cstring.c + + + + + ctime.c + 1 + ..\..\..\components\libc\compilers\common\ctime.c + + + + + cwchar.c + 1 + ..\..\..\components\libc\compilers\common\cwchar.c + + + + + CPU + + + backtrace.c + 1 + ..\..\..\libcpu\arm\common\backtrace.c + + + + + div0.c + 1 + ..\..\..\libcpu\arm\common\div0.c + + + + + showmem.c + 1 + ..\..\..\libcpu\arm\common\showmem.c + + + + + context_rvds.S + 2 + ..\..\..\libcpu\arm\cortex-m3\context_rvds.S + + + + + cpuport.c + 1 + ..\..\..\libcpu\arm\cortex-m3\cpuport.c + + + + + DeviceDrivers + + + completion.c + 1 + ..\..\..\components\drivers\ipc\completion.c + + + + + dataqueue.c + 1 + ..\..\..\components\drivers\ipc\dataqueue.c + + + + + pipe.c + 1 + ..\..\..\components\drivers\ipc\pipe.c + + + + + ringblk_buf.c + 1 + ..\..\..\components\drivers\ipc\ringblk_buf.c + + + + + ringbuffer.c + 1 + ..\..\..\components\drivers\ipc\ringbuffer.c + + + + + waitqueue.c + 1 + ..\..\..\components\drivers\ipc\waitqueue.c + + + + + workqueue.c + 1 + ..\..\..\components\drivers\ipc\workqueue.c + + + + + pin.c + 1 + ..\..\..\components\drivers\misc\pin.c + + + + + serial.c + 1 + ..\..\..\components\drivers\serial\serial.c + + + + + Drivers + + + startup_mm32f3270.s + 2 + ..\libraries\MM32F3270_HAL\CMSIS\Device\MM32\MM32F3277\Source\Templates\arm\startup_mm32f3270.s + + + + + board.c + 1 + board\board.c + + + + + mm32f3277g8p_msp.c + 1 + board\mm32f3277g8p_msp.c + + + + + user_key.c + 1 + board\ports\user_key.c + + + + + drv_common.c + 1 + ..\libraries\HAL_Drivers\drv_common.c + + + + + drv_gpio.c + 1 + ..\libraries\HAL_Drivers\drv_gpio.c + + + + + drv_uart.c + 1 + ..\libraries\HAL_Drivers\drv_uart.c + + + + + Filesystem + + + dfs_posix.c + 1 + ..\..\..\components\dfs\src\dfs_posix.c + + + + + dfs_fs.c + 1 + ..\..\..\components\dfs\src\dfs_fs.c + + + + + dfs.c + 1 + ..\..\..\components\dfs\src\dfs.c + + + + + dfs_file.c + 1 + ..\..\..\components\dfs\src\dfs_file.c + + + + + Finsh + + + shell.c + 1 + ..\..\..\components\finsh\shell.c + + + + + msh.c + 1 + ..\..\..\components\finsh\msh.c + + + + + msh_parse.c + 1 + ..\..\..\components\finsh\msh_parse.c + + + + + cmd.c + 1 + ..\..\..\components\finsh\cmd.c + + + + + msh_file.c + 1 + ..\..\..\components\finsh\msh_file.c + + + + + Kernel + + + clock.c + 1 + ..\..\..\src\clock.c + + + + + components.c + 1 + ..\..\..\src\components.c + + + + + device.c + 1 + ..\..\..\src\device.c + + + + + idle.c + 1 + ..\..\..\src\idle.c + + + + + ipc.c + 1 + ..\..\..\src\ipc.c + + + + + irq.c + 1 + ..\..\..\src\irq.c + + + + + kservice.c + 1 + ..\..\..\src\kservice.c + + + + + mem.c + 1 + ..\..\..\src\mem.c + + + + + mempool.c + 1 + ..\..\..\src\mempool.c + + + + + object.c + 1 + ..\..\..\src\object.c + + + + + scheduler.c + 1 + ..\..\..\src\scheduler.c + + + + + thread.c + 1 + ..\..\..\src\thread.c + + + + + timer.c + 1 + ..\..\..\src\timer.c + + + + + Libraries + + + hal_syscfg.c + 1 + ..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_syscfg.c + + + + + hal_exti.c + 1 + ..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_exti.c + + + + + hal_gpio.c + 1 + ..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_gpio.c + + + + + system_mm32f3277g.c + 1 + ..\libraries\MM32F3270_HAL\CMSIS\Device\MM32\MM32F3277\Source\Templates\system_mm32f3277g.c + + + + + hal_dma.c + 1 + ..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_dma.c + + + + + hal_rcc.c + 1 + ..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_rcc.c + + + + + hal_uart.c + 1 + ..\libraries\MM32F3270_HAL\MM32F3270_HAL_Driver\Src\hal_uart.c + + + + + + + + + + + + + + + template + 1 + + + +     diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.h b/bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.h new file mode 100644 index 0000000000..42daadd87a --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.h @@ -0,0 +1,211 @@ +#ifndef RT_CONFIG_H__ +#define RT_CONFIG_H__ + +/* Automatically generated file; DO NOT EDIT. */ +/* RT-Thread Configuration */ + +/* RT-Thread Kernel */ + +#define RT_NAME_MAX 8 +#define RT_ALIGN_SIZE 4 +#define RT_THREAD_PRIORITY_32 +#define RT_THREAD_PRIORITY_MAX 32 +#define RT_TICK_PER_SECOND 1000 +#define RT_USING_OVERFLOW_CHECK +#define RT_USING_HOOK +#define RT_HOOK_USING_FUNC_PTR +#define RT_USING_IDLE_HOOK +#define RT_IDLE_HOOK_LIST_SIZE 4 +#define IDLE_THREAD_STACK_SIZE 256 +#define RT_USING_TIMER_SOFT +#define RT_TIMER_THREAD_PRIO 4 +#define RT_TIMER_THREAD_STACK_SIZE 512 + +/* kservice optimization */ + +#define RT_KSERVICE_USING_STDLIB +#define RT_DEBUG + +/* Inter-Thread communication */ + +#define RT_USING_SEMAPHORE +#define RT_USING_MUTEX +#define RT_USING_EVENT +#define RT_USING_MAILBOX +#define RT_USING_MESSAGEQUEUE + +/* Memory Management */ + +#define RT_USING_MEMPOOL +#define RT_USING_SMALL_MEM +#define RT_USING_SMALL_MEM_AS_HEAP +#define RT_USING_HEAP + +/* Kernel Device Object */ + +#define RT_USING_DEVICE +#define RT_USING_CONSOLE +#define RT_CONSOLEBUF_SIZE 128 +#define RT_CONSOLE_DEVICE_NAME "uart1" +#define RT_VER_NUM 0x50000 +#define ARCH_ARM +#define RT_USING_CPU_FFS +#define ARCH_ARM_CORTEX_M +#define ARCH_ARM_CORTEX_M3 + +/* RT-Thread Components */ + +#define RT_USING_COMPONENTS_INIT +#define RT_USING_USER_MAIN +#define RT_MAIN_THREAD_STACK_SIZE 2048 +#define RT_MAIN_THREAD_PRIORITY 10 +#define RT_USING_MSH +#define RT_USING_FINSH +#define FINSH_USING_MSH +#define FINSH_THREAD_NAME "tshell" +#define FINSH_THREAD_PRIORITY 20 +#define FINSH_THREAD_STACK_SIZE 4096 +#define FINSH_USING_HISTORY +#define FINSH_HISTORY_LINES 5 +#define FINSH_USING_SYMTAB +#define FINSH_CMD_SIZE 80 +#define MSH_USING_BUILT_IN_COMMANDS +#define FINSH_USING_DESCRIPTION +#define FINSH_ARG_MAX 10 +#define RT_USING_DFS +#define DFS_USING_POSIX +#define DFS_USING_WORKDIR +#define DFS_FILESYSTEMS_MAX 4 +#define DFS_FILESYSTEM_TYPES_MAX 4 +#define DFS_FD_MAX 16 + +/* Device Drivers */ + +#define RT_USING_DEVICE_IPC +#define RT_USING_SERIAL +#define RT_USING_SERIAL_V1 +#define RT_SERIAL_USING_DMA +#define RT_SERIAL_RB_BUFSZ 64 +#define RT_USING_PIN + +/* Using USB */ + + +/* C/C++ and POSIX layer */ + +#define RT_LIBC_DEFAULT_TIMEZONE 8 + +/* POSIX (Portable Operating System Interface) layer */ + + +/* Interprocess Communication (IPC) */ + + +/* Socket is in the 'Network' category */ + + +/* Network */ + + +/* Utilities */ + + +/* RT-Thread Utestcases */ + + +/* RT-Thread online packages */ + +/* IoT - internet of things */ + + +/* Wi-Fi */ + +/* Marvell WiFi */ + + +/* Wiced WiFi */ + + +/* IoT Cloud */ + + +/* security packages */ + + +/* language packages */ + +/* JSON: JavaScript Object Notation, a lightweight data-interchange format */ + + +/* XML: Extensible Markup Language */ + + +/* multimedia packages */ + +/* LVGL: powerful and easy-to-use embedded GUI library */ + + +/* u8g2: a monochrome graphic library */ + + +/* PainterEngine: A cross-platform graphics application framework written in C language */ + + +/* tools packages */ + + +/* system packages */ + +/* enhanced kernel services */ + + +/* acceleration: Assembly language or algorithmic acceleration packages */ + + +/* CMSIS: ARM Cortex-M Microcontroller Software Interface Standard */ + + +/* Micrium: Micrium software products porting for RT-Thread */ + + +/* peripheral libraries and drivers */ + + +/* Kendryte SDK */ + + +/* AI packages */ + + +/* miscellaneous packages */ + +/* project laboratory */ + +/* samples: kernel and components samples */ + + +/* entertainment: terminal games and other interesting software packages */ + +#define SOC_FAMILY_MM32 +#define SOC_SERIES_MM32F3277 + +/* Hardware Drivers Config */ + +#define SOC_MM32F3277 + +/* Onboard Peripheral Drivers */ + +#define BSP_USING_USB_TO_USART +#define BSP_USING_USER_LED +#define BSP_USING_USER_KEY + +/* On-chip Peripheral Drivers */ + +#define BSP_USING_GPIO +#define BSP_USING_UART +#define BSP_USING_UART1 + +/* Board extended module Drivers */ + + +#endif diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.py b/bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.py new file mode 100644 index 0000000000..8460077322 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/rtconfig.py @@ -0,0 +1,184 @@ +import os + +# toolchains options +ARCH='arm' +CPU='cortex-m3' +CROSS_TOOL='gcc' + +# bsp lib config +BSP_LIBRARY_TYPE = None + +if os.getenv('RTT_CC'): + CROSS_TOOL = os.getenv('RTT_CC') +if os.getenv('RTT_ROOT'): + RTT_ROOT = os.getenv('RTT_ROOT') + +# cross_tool provides the cross compiler +# EXEC_PATH is the compiler execute path, for example, CodeSourcery, Keil MDK, IAR +if CROSS_TOOL == 'gcc': + PLATFORM = 'gcc' + EXEC_PATH = r'C:\Users\XXYYZZ' +elif CROSS_TOOL == 'keil': + PLATFORM = 'armcc' + EXEC_PATH = r'C:/Keil_v5' +elif CROSS_TOOL == 'iar': + PLATFORM = 'iar' + EXEC_PATH = r'C:/Program Files (x86)/IAR Systems/Embedded Workbench 8.2' + +if os.getenv('RTT_EXEC_PATH'): + EXEC_PATH = os.getenv('RTT_EXEC_PATH') + +BUILD = 'debug' + +if PLATFORM == 'gcc': + # toolchains + PREFIX = 'arm-none-eabi-' + CC = PREFIX + 'gcc' + AS = PREFIX + 'gcc' + AR = PREFIX + 'ar' + CXX = PREFIX + 'g++' + LINK = PREFIX + 'gcc' + TARGET_EXT = 'elf' + SIZE = PREFIX + 'size' + OBJDUMP = PREFIX + 'objdump' + OBJCPY = PREFIX + 'objcopy' + + DEVICE = ' -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections' + CFLAGS = DEVICE + ' -Dgcc' + AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp -Wa,-mimplicit-it=thumb ' + LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rt-thread.map,-cref,-u,Reset_Handler -T board/linker_scripts/link.ld' + + CPATH = '' + LPATH = '' + + if BUILD == 'debug': + CFLAGS += ' -O0 -gdwarf-2 -g' + AFLAGS += ' -gdwarf-2' + else: + CFLAGS += ' -O2' + + CXXFLAGS = CFLAGS + + POST_ACTION = OBJCPY + ' -O binary $TARGET rtthread.bin\n' + SIZE + ' $TARGET \n' + +elif PLATFORM == 'armcc': + # toolchains + CC = 'armcc' + CXX = 'armcc' + AS = 'armasm' + AR = 'armar' + LINK = 'armlink' + TARGET_EXT = 'axf' + + DEVICE = ' --cpu Cortex-M3 ' + CFLAGS = '-c ' + DEVICE + ' --apcs=interwork --c99' + AFLAGS = DEVICE + ' --apcs=interwork ' + LFLAGS = DEVICE + ' --scatter "board\linker_scripts\link.sct" --info sizes --info totals --info unused --info veneers --list rt-thread.map --strict' + CFLAGS += ' -I' + EXEC_PATH + '/ARM/ARMCC/include' + LFLAGS += ' --libpath=' + EXEC_PATH + '/ARM/ARMCC/lib' + + CFLAGS += ' -D__MICROLIB ' + AFLAGS += ' --pd "__MICROLIB SETA 1" ' + LFLAGS += ' --library_type=microlib ' + EXEC_PATH += '/ARM/ARMCC/bin/' + + if BUILD == 'debug': + CFLAGS += ' -g -O0' + AFLAGS += ' -g' + else: + CFLAGS += ' -O2' + + CXXFLAGS = CFLAGS + CFLAGS += ' -std=c99' + + POST_ACTION = 'fromelf --bin $TARGET --output rtthread.bin \nfromelf -z $TARGET' + +elif PLATFORM == 'armclang': + # toolchains + CC = 'armclang' + CXX = 'armclang' + AS = 'armasm' + AR = 'armar' + LINK = 'armlink' + TARGET_EXT = 'axf' + + DEVICE = ' --cpu Cortex-M3 ' + CFLAGS = ' --target=arm-arm-none-eabi -mcpu=cortex-m3 ' + CFLAGS += ' -mcpu=cortex-m3 ' + CFLAGS += ' -c -fno-rtti -funsigned-char -fshort-enums -fshort-wchar ' + CFLAGS += ' -gdwarf-3 -ffunction-sections ' + AFLAGS = DEVICE + ' --apcs=interwork ' + LFLAGS = DEVICE + ' --info sizes --info totals --info unused --info veneers ' + LFLAGS += ' --list rt-thread.map ' + LFLAGS += r' --strict --scatter "board\linker_scripts\link.sct" ' + CFLAGS += ' -I' + EXEC_PATH + '/ARM/ARMCLANG/include' + LFLAGS += ' --libpath=' + EXEC_PATH + '/ARM/ARMCLANG/lib' + + EXEC_PATH += '/ARM/ARMCLANG/bin/' + + if BUILD == 'debug': + CFLAGS += ' -g -O1' # armclang recommend + AFLAGS += ' -g' + else: + CFLAGS += ' -O2' + + CXXFLAGS = CFLAGS + CFLAGS += ' -std=c99' + + POST_ACTION = 'fromelf --bin $TARGET --output rtthread.bin \nfromelf -z $TARGET' + +elif PLATFORM == 'iar': + # toolchains + CC = 'iccarm' + CXX = 'iccarm' + AS = 'iasmarm' + AR = 'iarchive' + LINK = 'ilinkarm' + TARGET_EXT = 'out' + + DEVICE = '-Dewarm' + + CFLAGS = DEVICE + CFLAGS += ' --diag_suppress Pa050' + CFLAGS += ' --no_cse' + CFLAGS += ' --no_unroll' + CFLAGS += ' --no_inline' + CFLAGS += ' --no_code_motion' + CFLAGS += ' --no_tbaa' + CFLAGS += ' --no_clustering' + CFLAGS += ' --no_scheduling' + CFLAGS += ' --endian=little' + CFLAGS += ' --cpu=Cortex-M3' + CFLAGS += ' -e' + CFLAGS += ' --fpu=None' + CFLAGS += ' --dlib_config "' + EXEC_PATH + '/arm/INC/c/DLib_Config_Normal.h"' + CFLAGS += ' --silent' + + AFLAGS = DEVICE + AFLAGS += ' -s+' + AFLAGS += ' -w+' + AFLAGS += ' -r' + AFLAGS += ' --cpu Cortex-M3' + AFLAGS += ' --fpu None' + AFLAGS += ' -S' + + if BUILD == 'debug': + CFLAGS += ' --debug' + CFLAGS += ' -On' + else: + CFLAGS += ' -Oh' + + LFLAGS = ' --config "board/linker_scripts/link.icf"' + LFLAGS += ' --entry __iar_program_start' + + CXXFLAGS = CFLAGS + + EXEC_PATH = EXEC_PATH + '/arm/bin/' + POST_ACTION = 'ielftool --bin $TARGET rtthread.bin' + +def dist_handle(BSP_ROOT, dist_dir): + import sys + cwd_path = os.getcwd() + sys.path.append(os.path.join(os.path.dirname(BSP_ROOT), 'tools')) + from sdk_dist import dist_do_building + dist_do_building(BSP_ROOT, dist_dir) diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/template.ewp b/bsp/mm32/mm32f3270-100ask-pitaya/template.ewp new file mode 100644 index 0000000000..96539e7b9d --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/template.ewp @@ -0,0 +1,2074 @@ + + + 3 + + Debug + + ARM + + 1 + + General + 3 + + 31 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ICCARM + 2 + + 35 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AARM + 2 + + 10 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + OBJCOPY + 0 + + 1 + 1 + 1 + + + + + + + + + CUSTOM + 3 + + + + 0 + + + + BICOMP + 0 + + + + BUILDACTION + 1 + + + + + + + ILINK + 0 + + 22 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + IARCHIVE + 0 + + 0 + 1 + 1 + + + + + + + BILINK + 0 + + + + + Release + + ARM + + 0 + + General + 3 + + 31 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ICCARM + 2 + + 35 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AARM + 2 + + 10 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + OBJCOPY + 0 + + 1 + 1 + 0 + + + + + + + + + CUSTOM + 3 + + + + 0 + + + + BICOMP + 0 + + + + BUILDACTION + 1 + + + + + + + ILINK + 0 + + 22 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + IARCHIVE + 0 + + 0 + 1 + 0 + + + + + + + BILINK + 0 + + + + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/template.eww b/bsp/mm32/mm32f3270-100ask-pitaya/template.eww new file mode 100644 index 0000000000..f698346f0c --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/template.eww @@ -0,0 +1,7 @@ + + + + $WS_DIR$\template.ewp + + + diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/template.uvoptx b/bsp/mm32/mm32f3270-100ask-pitaya/template.uvoptx new file mode 100644 index 0000000000..9e085f45b4 --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/template.uvoptx @@ -0,0 +1,185 @@ + + + + 1.0 + +
    ### uVision Project, (C) Keil Software
    + + + *.c + *.s*; *.src; *.a* + *.obj; *.o + *.lib + *.txt; *.h; *.inc; *.md + *.plm + *.cpp + 0 + + + + 0 + 0 + + + + rt-thread + 0x4 + ARM-ADS + + 12000000 + + 1 + 1 + 0 + 1 + 0 + + + 1 + 65535 + 0 + 0 + 0 + + + 79 + 66 + 8 + .\Listings\ + + + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 0 + 0 + 0 + 0 + + + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 0 + + + 0 + 0 + 1 + + 255 + + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 1 + 1 + 0 + 0 + 1 + 0 + 0 + 3 + + + + + + + + + + + BIN\CMSIS_AGDI.dll + + + + 0 + CMSIS_AGDI + -X"Any" -UAny -O206 -S0 -C0 -P00000000 -N00("ARM CoreSight SW-DP") -D00(2BA01477) -L00(0) -TO65554 -TC10000000 -TT10000000 -TP20 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -FO15 -FD20000000 -FC1000 -FN1 -FF0MM32F3270_512.FLM -FS08000000 -FL080000 -FP0($$Device:MM32F3277G8P$Flash\MM32F3270_512.FLM) + + + 0 + UL2CM3 + UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0MM32F3270_512 -FS08000000 -FL080000 -FP0($$Device:MM32F3277G8P$Flash\MM32F3270_512.FLM)) + + + + + 0 + + + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + + + + 0 + 0 + 0 + + + + + + + + + + + + + Source Group 1 + 0 + 0 + 0 + 0 + + +     diff --git a/bsp/mm32/mm32f3270-100ask-pitaya/template.uvprojx b/bsp/mm32/mm32f3270-100ask-pitaya/template.uvprojx new file mode 100644 index 0000000000..0ad053da2b --- /dev/null +++ b/bsp/mm32/mm32f3270-100ask-pitaya/template.uvprojx @@ -0,0 +1,405 @@ + + + + 2.1 + +
    ### uVision Project, (C) Keil Software
    + + + + rt-thread + 0x4 + ARM-ADS + 5060960::V5.06 update 7 (build 960)::.\ARMCC + 0 + + + MM32F3277G8P + MindMotion + MindMotion.MM32F3270_DFP.1.0.5 + http://www.mindmotion.com.cn/Download/MDK_KEIL/ + IRAM(0x20000000,0x20000) IROM(0x08000000,0x80000) CPUTYPE("Cortex-M3") CLOCK(12000000) ELITTLE + + + UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0MM32F3270_512 -FS08000000 -FL080000 -FP0($$Device:MM32F3277G8P$Flash\MM32F3270_512.FLM)) + 0 + $$Device:MM32F3277G8P$Device\MM32F327x\Include\mm32_device.h + + + + + + + + + + $$Device:MM32F3277G8P$SVD\MM32F3270.svd + 0 + 0 + + + + + + + 0 + 0 + 0 + 0 + 1 + + .\Objects\ + rt-thread + 1 + 0 + 1 + 1 + 1 + .\Listings\ + 1 + 0 + 0 + + 0 + 0 + + + 0 + 0 + 0 + 0 + + + 0 + 0 + + + 0 + 0 + 0 + 0 + + + 1 + 0 + fromelf --bin !L --output rtthread.bin + + 0 + 0 + 0 + 0 + + 0 + + + + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 3 + + + 1 + + + SARMCM3.DLL + -REMAP + DCM.DLL + -pCM3 + SARMCM3.DLL + + TCM.DLL + -pCM3 + + + + 1 + 0 + 0 + 0 + 16 + + + + + 1 + 0 + 0 + 1 + 1 + 4096 + + 1 + BIN\UL2CM3.DLL + "" () + + + + + 0 + + + + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 1 + 0 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 0 + "Cortex-M3" + + 0 + 0 + 0 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 8 + 0 + 0 + 0 + 0 + 3 + 3 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 1 + 0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x20000000 + 0x20000 + + + 1 + 0x8000000 + 0x80000 + + + 0 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x8000000 + 0x80000 + + + 1 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x20000000 + 0x20000 + + + 0 + 0x0 + 0x0 + + + + + + 1 + 1 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 2 + 0 + 0 + 1 + 1 + 0 + 3 + 3 + 1 + 1 + 0 + 0 + 0 + + + + + + + + + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + + + + + + + + + 0 + 0 + 0 + 0 + 1 + 0 + 0x08000000 + 0x20000000 + + .\board\linker_scripts\link.sct + + + + + + + + + + + Source Group 1 + + + + + + + + + + + + + + + template + 1 + + + + +     diff --git a/bsp/mm32/tools/sdk_dist.py b/bsp/mm32/tools/sdk_dist.py new file mode 100644 index 0000000000..b10e02d7d7 --- /dev/null +++ b/bsp/mm32/tools/sdk_dist.py @@ -0,0 +1,22 @@ +import os +import sys +import shutil + +cwd_path = os.getcwd() +sys.path.append(os.path.join(os.path.dirname(cwd_path), 'rt-thread', 'tools')) + + +# BSP dist function +def dist_do_building(BSP_ROOT, dist_dir): + from mkdist import bsp_copy_files + import rtconfig + + print("=> copy mm32 bsp library") + library_dir = os.path.join(dist_dir, 'libraries') + library_path = os.path.join(os.path.dirname(BSP_ROOT), 'libraries') + bsp_copy_files(os.path.join(library_path, rtconfig.BSP_LIBRARY_TYPE), + os.path.join(library_dir, rtconfig.BSP_LIBRARY_TYPE)) + + print("=> copy bsp drivers") + bsp_copy_files(os.path.join(library_path, 'HAL_Drivers'), os.path.join(library_dir, 'HAL_Drivers')) + shutil.copyfile(os.path.join(library_path, 'Kconfig'), os.path.join(library_dir, 'Kconfig')) diff --git a/bsp/mm32/tools/upgrade.py b/bsp/mm32/tools/upgrade.py new file mode 100644 index 0000000000..1ad9a67512 --- /dev/null +++ b/bsp/mm32/tools/upgrade.py @@ -0,0 +1,145 @@ +# +# File : upgrade.py +# This file is part of RT-Thread RTOS +# COPYRIGHT (C) 2006 - 2021, RT-Thread Development Team +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Change Logs: +# Date Author Notes +# 2021-10-11 Meco Man First version +# + +# 本文件用于在HAL库更新之后 +# 1.对gcc的汇编启动文件中main替换为entry函数 +# 2.将启动文件heap降为0(Keil IAR) +# 3.将GCC的堆大小扩展到0x400，与Keil IAR保持一致 + + +#使用方法：运行脚本，将bsp/stm32的绝对路径传给脚本即可，如：C:\Users\92036\Desktop\rt-thread\bsp\stm32 + +#特别说明：此脚本是借用RTT原BSP中STM32的，对ST的开源表示非常感谢！！！ + +import os +import re + +#将'bl main' 替换为 'bl entry' +def main2entry(path): + oldline = '' + newline = '' + + for root, dirs, files in os.walk(path): #递归扫描里面的所有文件 + for file in files: + if os.path.splitext(file)[1] == '.s': #找.s文件 + file_path = os.path.join(root,file) + flag_need_replace = False + with open(file_path,'r+',) as f: + while True: + line = f.readline() + if line == '': + break + elif ('bl' in line) and ('main' in line): #发现'bl main' + oldline = line # bl main + newline = line.replace('main', 'entry') #将main替换为entry，形成新的字符串 + flag_need_replace = True #标记该文件需要做entry替换 + break + + if (flag_need_replace == True): #若该文件需要将main替换为entry + f.seek(0) + content = f.read() + f.seek(0) + f.truncate() + newcontent = content.replace(oldline, newline) + f.write(newcontent) + +#将启动文件的heap降为0 +def heap2zero(path): + oldline = '' + newline = '' + for root, dirs, files in os.walk(path): #递归扫描里面的所有文件 + for file in files: + file_path = os.path.join(root,file) + if os.path.splitext(file)[1] == '.s': #找.s文件 + with open(file_path,'r+',) as f: + flag_need_replace = False + while True: + line = f.readline() + if line == '': + break + + re_result = re.match('\s*Heap_Size\s+EQU\s+0[xX][0-9a-fA-F]+', line) #MDK的表示方法 + if re_result != None: + oldline = line + newline = re.sub('0[xX][0-9a-fA-F]+','0x00000000', oldline) + flag_need_replace = True + break + + if flag_need_replace == True: + f.seek(0) + content = f.read() + f.seek(0) + f.truncate() + newcontent = content.replace(oldline, newline) + f.write(newcontent) + + elif os.path.splitext(file)[1] == '.icf': #找.icf文件(IAR) + with open(file_path,'r+',) as f: + flag_need_replace = False + while True: + line = f.readline() + if line == '': + break + + re_result = re.match('\s*define\s+symbol\s+__ICFEDIT_size_heap__\s*=\s*0[xX][0-9a-fA-F]+', line) #IAR的表示方法 + if re_result != None: + oldline = line + newline = re.sub('0[xX][0-9a-fA-F]+','0x000', oldline) + flag_need_replace = True + break + + if flag_need_replace == True: + f.seek(0) + content = f.read() + f.seek(0) + f.truncate() + newcontent = content.replace(oldline, newline) + f.write(newcontent) + + elif os.path.splitext(file)[1] == '.lds': #找.lds文件(GCC) + with open(file_path,'r+',) as f: + flag_need_replace = False + while True: + line = f.readline() + if line == '': + break + + re_result = re.match('\s*_system_stack_size\s*=\s*0[xX][0-9a-fA-F]+', line) #GCC的表示方法, 将默认的栈大小增加到0x400 + if re_result != None: + oldline = line + newline = re.sub('0[xX][0-9a-fA-F]+','0x400', oldline) + flag_need_replace = True + break + + if flag_need_replace == True: + f.seek(0) + content = f.read() + f.seek(0) + f.truncate() + newcontent = content.replace(oldline, newline) + f.write(newcontent) + +folder_path = input('please input path:') +main2entry(folder_path) +heap2zero(folder_path) diff --git a/bsp/stm32/stm32f103-100ask-mini/README.md b/bsp/stm32/stm32f103-100ask-mini/README.md index 0e557a9eec..917bdaf630 100644 --- a/bsp/stm32/stm32f103-100ask-mini/README.md +++ b/bsp/stm32/stm32f103-100ask-mini/README.md @@ -7,6 +7,7 @@ 主要内容如下： * 开发板资源介绍 + * BSP快速上手 * 进阶使用方法 @@ -37,26 +38,26 @@ STM32F103 Mini开发板是百问网推出的一块基于ARM Cortex-M3内核的 本BSP目前对外设的支持情况如下： -| 板载外设 | 支持情况 | 备注 | -| ------------ | :----------: | ------------------------------------- | -| USB转串口 | 支持 | UART1 | -| 用户LED | 支持 | 蓝灯（PA1） | -| 用户按键 | 支持 | KEY(PA0) | -| **片上外设** | **支持情况** | **备注** | -| GPIO | 支持 | PA0, PA1... PK15 ---> PIN: 0, 1...176 | -| UART | 支持 | UART1/2/3 | -| SPI | 支持 | SPI1/2 | +| 板载外设 | 支持情况 | 备注 | +| -------- |:--------:| ------------------------------------- | +| USB转串口 | 支持 | UART1 | +| 用户LED | 支持 | 蓝灯（PA1） | +| 用户按键 | 支持 | KEY(PA0) | +| **片上外设** | **支持情况** | **备注** | +| GPIO | 支持 | PA0, PA1... PK15 ---> PIN: 0, 1...176 | +| UART | 支持 | UART1/2/3 | +| SPI | 支持 | SPI1/2 | ## 使用说明 使用说明分为如下两个章节： - 快速上手 - + 本章节是为刚接触 RT-Thread 的新手准备的使用说明，遵循简单的步骤即可将 RT-Thread 操作系统运行在该开发板上，看到实验效果 。 - 进阶使用 - + 本章节是为需要在 RT-Thread 操作系统上使用更多开发板资源的开发者准备的。通过使用 ENV 工具对 BSP 进行配置，可以开启更多板载资源，实现更多高级功能。 ### 快速上手 @@ -71,7 +72,7 @@ STM32F103 Mini开发板是百问网推出的一块基于ARM Cortex-M3内核的 双击 project.uvprojx 文件，打开 MDK5 工程，编译并下载程序到开发板。 -> 工程默认配置使用 JLink 下载程序，在通过 JLink 连接开发板的基础上，点击下载按钮即可下载程序到开发板 +> 工程默认配置使用 ST-Link 下载程序，在通过 ST-Link连接开发板的基础上，点击下载按钮即可下载程序到开发板 #### 运行结果 diff --git a/bsp/stm32/stm32f103-100ask-pro/README.md b/bsp/stm32/stm32f103-100ask-pro/README.md index 521be53dde..25a34f7e36 100644 --- a/bsp/stm32/stm32f103-100ask-pro/README.md +++ b/bsp/stm32/stm32f103-100ask-pro/README.md @@ -78,7 +78,7 @@ STM32F103 Pro开发板是百问网推出的一块基于ARM Cortex-M3内核的开 双击 project.uvprojx 文件，打开 MDK5 工程，编译并下载程序到开发板。 -> 工程默认配置使用 JLink 下载程序，在通过 JLink 连接开发板的基础上，点击下载按钮即可下载程序到开发板 +> 工程默认配置使用 ST-Link 下载程序，在通过 ST-Link 连接开发板的基础上，点击下载按钮即可下载程序到开发板 #### 运行结果