From a0edeaee2968ec556aa9e9eef09895b4d37db8ba Mon Sep 17 00:00:00 2001 From: "ivan.ruzavin" Date: Wed, 30 Oct 2024 13:33:26 +0100 Subject: [PATCH 1/8] Added USB schemas for STM32L412/422 MCUs --- .../STM32L412C8/STM32L412C8_USB.schema | 178 ++++++++++++++++++ .../STM32L412CB/STM32L412CB_USB.schema | 178 ++++++++++++++++++ .../STM32L412K8/STM32L412K8_USB.schema | 178 ++++++++++++++++++ .../STM32L412KB/STM32L412KB_USB.schema | 178 ++++++++++++++++++ .../STM32L412R8/STM32L412R8_USB.schema | 178 ++++++++++++++++++ .../STM32L412RB/STM32L412RB_USB.schema | 178 ++++++++++++++++++ .../STM32L412T8/STM32L412T8_USB.schema | 178 ++++++++++++++++++ .../STM32L412TB/STM32L412TB_USB.schema | 178 ++++++++++++++++++ .../STM32L422CB/STM32L422CB_USB.schema | 178 ++++++++++++++++++ .../STM32L422KB/STM32L422KB_USB.schema | 178 ++++++++++++++++++ .../STM32L422RB/STM32L422RB_USB.schema | 178 ++++++++++++++++++ .../STM32L422TB/STM32L422TB_USB.schema | 178 ++++++++++++++++++ 12 files changed, 2136 insertions(+) create mode 100644 ARM/gcc_clang/schemas/STM32L412C8/STM32L412C8_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L412CB/STM32L412CB_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L412K8/STM32L412K8_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L412KB/STM32L412KB_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L412R8/STM32L412R8_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L412RB/STM32L412RB_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L412T8/STM32L412T8_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L412TB/STM32L412TB_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L422CB/STM32L422CB_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L422KB/STM32L422KB_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L422RB/STM32L422RB_USB.schema create mode 100644 ARM/gcc_clang/schemas/STM32L422TB/STM32L422TB_USB.schema diff --git a/ARM/gcc_clang/schemas/STM32L412C8/STM32L412C8_USB.schema b/ARM/gcc_clang/schemas/STM32L412C8/STM32L412C8_USB.schema new file mode 100644 index 000000000..5c33fe37f --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412C8/STM32L412C8_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412C8.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412C8_USB", + "mcu": "STM32L412C8", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L412CB/STM32L412CB_USB.schema b/ARM/gcc_clang/schemas/STM32L412CB/STM32L412CB_USB.schema new file mode 100644 index 000000000..ca6c9edaf --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412CB/STM32L412CB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412CB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412CB_USB", + "mcu": "STM32L412CB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L412K8/STM32L412K8_USB.schema b/ARM/gcc_clang/schemas/STM32L412K8/STM32L412K8_USB.schema new file mode 100644 index 000000000..684d6d440 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412K8/STM32L412K8_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412K8.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412K8_USB", + "mcu": "STM32L412K8", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L412KB/STM32L412KB_USB.schema b/ARM/gcc_clang/schemas/STM32L412KB/STM32L412KB_USB.schema new file mode 100644 index 000000000..b7ad7d6d2 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412KB/STM32L412KB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412KB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412KB_USB", + "mcu": "STM32L412KB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L412R8/STM32L412R8_USB.schema b/ARM/gcc_clang/schemas/STM32L412R8/STM32L412R8_USB.schema new file mode 100644 index 000000000..6abdf6f2a --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412R8/STM32L412R8_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412R8.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412R8_USB", + "mcu": "STM32L412R8", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L412RB/STM32L412RB_USB.schema b/ARM/gcc_clang/schemas/STM32L412RB/STM32L412RB_USB.schema new file mode 100644 index 000000000..69680d9d1 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412RB/STM32L412RB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412RB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412RB_USB", + "mcu": "STM32L412RB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L412T8/STM32L412T8_USB.schema b/ARM/gcc_clang/schemas/STM32L412T8/STM32L412T8_USB.schema new file mode 100644 index 000000000..93a0fff36 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412T8/STM32L412T8_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412T8.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412T8_USB", + "mcu": "STM32L412T8", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L412TB/STM32L412TB_USB.schema b/ARM/gcc_clang/schemas/STM32L412TB/STM32L412TB_USB.schema new file mode 100644 index 000000000..619d9a8c3 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L412TB/STM32L412TB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L412TB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L412TB_USB", + "mcu": "STM32L412TB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L422CB/STM32L422CB_USB.schema b/ARM/gcc_clang/schemas/STM32L422CB/STM32L422CB_USB.schema new file mode 100644 index 000000000..7a86c8dc6 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L422CB/STM32L422CB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L422CB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L422CB_USB", + "mcu": "STM32L422CB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L422KB/STM32L422KB_USB.schema b/ARM/gcc_clang/schemas/STM32L422KB/STM32L422KB_USB.schema new file mode 100644 index 000000000..93a6f98d4 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L422KB/STM32L422KB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L422KB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L422KB_USB", + "mcu": "STM32L422KB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L422RB/STM32L422RB_USB.schema b/ARM/gcc_clang/schemas/STM32L422RB/STM32L422RB_USB.schema new file mode 100644 index 000000000..390183965 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L422RB/STM32L422RB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L422RB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L422RB_USB", + "mcu": "STM32L422RB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} diff --git a/ARM/gcc_clang/schemas/STM32L422TB/STM32L422TB_USB.schema b/ARM/gcc_clang/schemas/STM32L422TB/STM32L422TB_USB.schema new file mode 100644 index 000000000..4364169c2 --- /dev/null +++ b/ARM/gcc_clang/schemas/STM32L422TB/STM32L422TB_USB.schema @@ -0,0 +1,178 @@ +{ + "compiler_flags": "", + "linker_flags": "", + "def_path": "ARM/gcc-arm-none-eabi/core/def/STM32L422TB.json", + "flash": 131071, + "ram": 49151, + "settings": { + "clock": "80", + "scheme": "STM32L422TB_USB", + "mcu": "STM32L422TB", + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "name": null, + "config_registers": [ + { + "fields": [ + { + "key": "MSION", + "value": "00000000" + }, + { + "key": "MSIPLLEN", + "value": "00000000" + }, + { + "key": "MSIRGSEL", + "value": "00000000" + }, + { + "key": "MSIRANGE", + "value": "00000060" + }, + { + "key": "HSION", + "value": "00000100" + }, + { + "key": "HSIKERON", + "value": "00000000" + }, + { + "key": "HSIASFS", + "value": "00000800" + }, + { + "key": "HSEON", + "value": "00000000" + }, + { + "key": "HSEBYP", + "value": "00000000" + }, + { + "key": "CSSON", + "value": "00000000" + }, + { + "key": "PLLON", + "value": "01000000" + }, + { + "key": "PLLSAI1ON", + "value": "00000000" + } + ], + "key": "RCC_CR" + }, + { + "fields": [ + { + "key": "SW", + "value": "00000003" + }, + { + "key": "HPRE", + "value": "00000000" + }, + { + "key": "PPRE1", + "value": "00000000" + }, + { + "key": "PPRE2", + "value": "00000000" + }, + { + "key": "STOPWUCK", + "value": "00000000" + }, + { + "key": "MCOSEL", + "value": "00000000" + }, + { + "key": "MCOPRE", + "value": "00000000" + } + ], + "key": "RCC_CFGR" + }, + { + "fields": [ + { + "key": "PLLSRC", + "value": "00000002" + }, + { + "key": "PLLM", + "value": "00000000" + }, + { + "key": "PLLN", + "value": "00000a00" + }, + { + "key": "PLLPEN", + "value": "00000000" + }, + { + "key": "PLLP", + "value": "00000000" + }, + { + "key": "PLLQEN", + "value": "00000000" + }, + { + "key": "PLLQ", + "value": "00000000" + }, + { + "key": "PLLREN", + "value": "01000000" + }, + { + "key": "PLLR", + "value": "00000000" + } + ], + "key": "RCC_PLLCFGR" + }, + { + "fields": [ + { + "key": "LSION", + "value": "00000000" + }, + { + "key": "MSISRANGE", + "value": "00000600" + } + ], + "key": "RCC_CSR" + }, + { + "fields": { + "key": "VCORE", + "value": "00000200" + }, + "key": "PWR_CR1" + }, + { + "fields": { + "key": "HSI48ON", + "value": "00000001" + }, + "key": "RCC_CRRCR" + }, + { + "fields": { + "key": "CLK48SEL", + "value": "00000000" + }, + "key": "RCC_CCIPR" + } + ] + } +} From 468412038203f0fd6ecd983b2ff4dcac0c662dec Mon Sep 17 00:00:00 2001 From: github-actions Date: Thu, 31 Oct 2024 07:17:20 +0000 Subject: [PATCH 2/8] Updated necto_db_dev.db with latest merged release. --- necto_db_dev.db | Bin 9407488 -> 9411584 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/necto_db_dev.db b/necto_db_dev.db index 7606f843e2877d3c88c8978c6595eaba95268d00..2b4ca7ac0845993ba3fb6d4cf340aa06e9d7a8c8 100644 GIT binary patch delta 82442 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

LT5`9LyL8nuSg-2RIXvN(oMS;o&q+ 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 delta 80917 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 U*<&4_o3F>Xujj2Bw)u1aAF;tD`~Uy| From 6baf56d2c441063ac054b9b533b2cc20b1819c7c Mon Sep 17 00:00:00 2001 From: "ivan.ruzavin" Date: Mon, 28 Oct 2024 09:04:30 +0100 Subject: [PATCH 3/8] Added L422_RB_TB MCUs --- .../cmake/stm/delays/stm32l422rb_tb.cmake | 3 + ARM/gcc_clang/cmake/stm/stm32l422rb_tb.cmake | 7 + ARM/gcc_clang/def/STM32L422RB.json | 826 ++ ARM/gcc_clang/def/STM32L422TB.json | 826 ++ ARM/gcc_clang/def/stm/STM32L422RB/mcu.h | 11153 ++++++++++++++++ ARM/gcc_clang/def/stm/STM32L422TB/mcu.h | 11153 ++++++++++++++++ .../stm32l422rb/interrupts_mcu.h | 125 + .../stm32l422tb/interrupts_mcu.h | 125 + changelog/new_hw.md | 23 + .../queries/mcus/STM32L422RB/Devices.json | 18 + .../mcus/STM32L422RB/LinkerTables.json | 36 + .../queries/mcus/STM32L422TB/Devices.json | 18 + .../mcus/STM32L422TB/LinkerTables.json | 35 + 13 files changed, 24348 insertions(+) create mode 100644 ARM/gcc_clang/cmake/stm/delays/stm32l422rb_tb.cmake create mode 100644 ARM/gcc_clang/cmake/stm/stm32l422rb_tb.cmake create mode 100644 ARM/gcc_clang/def/STM32L422RB.json create mode 100644 ARM/gcc_clang/def/STM32L422TB.json create mode 100644 ARM/gcc_clang/def/stm/STM32L422RB/mcu.h create mode 100644 ARM/gcc_clang/def/stm/STM32L422TB/mcu.h create mode 100644 ARM/gcc_clang/interrupts/include/interrupts_mcu/stm32l422rb/interrupts_mcu.h create mode 100644 ARM/gcc_clang/interrupts/include/interrupts_mcu/stm32l422tb/interrupts_mcu.h create mode 100644 changelog/new_hw.md create mode 100644 resources/queries/mcus/STM32L422RB/Devices.json create mode 100644 resources/queries/mcus/STM32L422RB/LinkerTables.json create mode 100644 resources/queries/mcus/STM32L422TB/Devices.json create mode 100644 resources/queries/mcus/STM32L422TB/LinkerTables.json diff --git a/ARM/gcc_clang/cmake/stm/delays/stm32l422rb_tb.cmake b/ARM/gcc_clang/cmake/stm/delays/stm32l422rb_tb.cmake new file mode 100644 index 000000000..12c11fc8d --- /dev/null +++ b/ARM/gcc_clang/cmake/stm/delays/stm32l422rb_tb.cmake @@ -0,0 +1,3 @@ +if(${MCU_NAME} MATCHES "^STM32L422RB$|^STM32L422TB$") + list(APPEND local_list_macros "getClockValue(_clock) (_clock/1000UL/6)") +endif() diff --git a/ARM/gcc_clang/cmake/stm/stm32l422rb_tb.cmake b/ARM/gcc_clang/cmake/stm/stm32l422rb_tb.cmake new file mode 100644 index 000000000..090108135 --- /dev/null +++ b/ARM/gcc_clang/cmake/stm/stm32l422rb_tb.cmake @@ -0,0 +1,7 @@ +if(${MCU_NAME} MATCHES "^STM32L422RB$|^STM32L422TB$") + set(${linkerScript} linker_scripts/${vendor}/${mcu_match}.ld PARENT_SCOPE) + set(${startupFile} startup/${vendor}/${mcu_match}.s PARENT_SCOPE) + list(APPEND local_list_include system/src/${vendor}/system_stm32l_4xx.c) + list(APPEND local_list_include system/inc/${vendor}/system_stm32l_4xx.h) + list(APPEND local_list_install system/inc/${vendor}/system_stm32l_4xx.h) +endif() diff --git a/ARM/gcc_clang/def/STM32L422RB.json b/ARM/gcc_clang/def/STM32L422RB.json new file mode 100644 index 000000000..e307f40a7 --- /dev/null +++ b/ARM/gcc_clang/def/STM32L422RB.json @@ -0,0 +1,826 @@ +{ + "config_registers": [ + { + "address": "40021000", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "MSION", + "label": "MSI clock enable", + "mask": "00000001", + "settings": [ + { + "label": "MSI oscillator OFF", + "value": "00000000" + }, + { + "label": "MSI oscillator ON", + "value": "00000001" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MSIPLLEN", + "label": "MSI clock PLL enable", + "mask": "00000004", + "settings": [ + { + "label": "MSI PLL OFF", + "value": "00000000" + }, + { + "label": "MSI PLL ON", + "value": "00000004" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MSIRGSEL", + "label": "MSI clock range selection", + "mask": "00000008", + "settings": [ + { + "label": "MSI Range is provided in RCC_CSR register", + "value": "00000000" + }, + { + "label": "MSI Range is provided in RCC_CR register", + "value": "00000008" + } + ] + }, + { + "hidden": false, + "init": "00000060", + "key": "MSIRANGE", + "label": "MSI clock ranges in RCC_CR register", + "mask": "000000F0", + "settings": [ + { + "label": "range 0 around 100 kHz", + "value": "00000000" + }, + { + "label": "range 1 around 200 kHz", + "value": "00000010" + }, + { + "label": "range 2 around 400 kHz", + "value": "00000020" + }, + { + "label": "range 3 around 800 kHz", + "value": "00000030" + }, + { + "label": "range 4 around 1MHz", + "value": "00000040" + }, + { + "label": "range 5 around 2MHz", + "value": "00000050" + }, + { + "label": "range 6 around 4MHz", + "value": "00000060" + }, + { + "label": "range 7 around 8MHz", + "value": "00000070" + }, + { + "label": "range 8 around 16MHz", + "value": "00000080" + }, + { + "label": "range 9 around 24MHz", + "value": "00000090" + }, + { + "label": "range 10 around 32MHz", + "value": "000000A0" + }, + { + "label": "range 11 around 48MHz", + "value": "000000B0" + } + ] + }, + { + "hidden": false, + "init": "00000100", + "key": "HSION", + "label": "HSI clock enable", + "mask": "00000100", + "settings": [ + { + "label": "HSI16 oscillator OFF", + "value": "00000000" + }, + { + "label": "HSI16 oscillator ON", + "value": "00000100" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HSIKERON", + "label": "HSI16 always enable for peripheral kernels", + "mask": "00000200", + "settings": [ + { + "label": "No effect on HSI16 oscillator", + "value": "00000000" + }, + { + "label": "HSI16 oscillator is forced ON even in Stop mode", + "value": "00000200" + } + ] + }, + { + "hidden": false, + "init": "00000800", + "key": "HSIASFS", + "label": "HSI16 automatic start from Stop", + "mask": "00000800", + "settings": [ + { + "label": "HSI16 oscillator is not enabled by hardware when exiting Stop mode with MSI as wakeup clock", + "value": "00000000" + }, + { + "label": "HSI16 oscillator is enabled by hardware when exiting Stop mode with MSI as wakeup clock", + "value": "00000800" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HSEON", + "label": "HSE clock enable", + "mask": "00010000", + "settings": [ + { + "label": "HSE oscillator OFF", + "value": "00000000" + }, + { + "label": "HSE oscillator ON", + "value": "00010000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HSEBYP", + "label": "HSE crystal oscillator bypass", + "mask": "00040000", + "settings": [ + { + "label": "HSE crystal oscillator not bypassed", + "value": "00000000" + }, + { + "label": "HSE crystal oscillator bypassed with external clock", + "value": "00040000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "CSSON", + "label": "Clock security system enable", + "mask": "00080000", + "settings": [ + { + "label": "Clock security system OFF", + "value": "00000000" + }, + { + "label": "Clock security system ON", + "value": "00080000" + } + ] + }, + { + "hidden": false, + "init": "01000000", + "key": "PLLON", + "label": "Main PLL enable", + "mask": "01000000", + "settings": [ + { + "label": "PLL OFF", + "value": "00000000" + }, + { + "label": "PLL ON", + "value": "01000000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLSAI1ON", + "label": "SAI1 PLL enable", + "mask": "04000000", + "settings": [ + { + "label": "PLLSAI1 OFF", + "value": "00000000" + }, + { + "label": "PLLSAI1 ON", + "value": "04000000" + } + ] + } + ], + "key": "RCC_CR", + "unused": "00000000" + }, + { + "address": "40021008", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000003", + "key": "SW", + "label": "System clock switch", + "mask": "00000003", + "settings": [ + { + "label": "MSI selected as system clock", + "value": "00000000" + }, + { + "label": "HSI16 selected as system clock", + "value": "00000001" + }, + { + "label": "HSE selected as system clock", + "value": "00000002" + }, + { + "label": "PLL selected as system clock", + "value": "00000003" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HPRE", + "label": "Set and cleared by software to control the division factor of the AHB clock", + "mask": "000000F0", + "settings": [ + { + "label": "SYSCLK not divided", + "value": "00000000" + }, + { + "label": "SYSCLK divided by 2", + "value": "00000080" + }, + { + "label": "SYSCLK divided by 4", + "value": "00000090" + }, + { + "label": "SYSCLK divided by 8", + "value": "000000A0" + }, + { + "label": "SYSCLK divided by 16", + "value": "000000B0" + }, + { + "label": "SYSCLK divided by 64", + "value": "000000C0" + }, + { + "label": "SYSCLK divided by 128", + "value": "000000D0" + }, + { + "label": "SYSCLK divided by 256", + "value": "000000E0" + }, + { + "label": "SYSCLK divided by 512", + "value": "000000F0" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PPRE1", + "label": "APB low-speed prescaler (APB1)", + "mask": "00000700", + "settings": [ + { + "label": "HCLK not divided ", + "value": "00000000" + }, + { + "label": "HCLK divided by 2 ", + "value": "00000400" + }, + { + "label": "HCLK divided by 4 ", + "value": "00000500" + }, + { + "label": "HCLK divided by 8 ", + "value": "00000600" + }, + { + "label": "HCLK divided by 16 ", + "value": "00000700" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PPRE2", + "label": "APB high-speed prescaler (APB2)", + "mask": "00003800", + "settings": [ + { + "label": "HCLK not divided ", + "value": "00000000" + }, + { + "label": "HCLK divided by 2 ", + "value": "00002000" + }, + { + "label": "HCLK divided by 4 ", + "value": "00002800" + }, + { + "label": "HCLK divided by 8 ", + "value": "00003000" + }, + { + "label": "HCLK divided by 16 ", + "value": "00003800" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "STOPWUCK", + "label": "Wakeup from Stop and CSS backup clock selection", + "mask": "00008000", + "settings": [ + { + "label": "MSI oscillator selected as wakeup from stop clock and CSS backup clock", + "value": "00000000" + }, + { + "label": "HSI16 oscillator selected as wakeup from stop clock and CSS backup clock", + "value": "00008000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MCOSEL", + "label": "Microcontroller clock output", + "mask": "0F000000", + "settings": [ + { + "label": "MCO output disabled, no clock on MCO", + "value": "00000000" + }, + { + "label": "SYSCLK system clock selected", + "value": "01000000" + }, + { + "label": "MSI clock selected", + "value": "02000000" + }, + { + "label": "HSI16 clock selected", + "value": "03000000" + }, + { + "label": "HSE clock selected", + "value": "04000000" + }, + { + "label": "Main PLL clock selected", + "value": "05000000" + }, + { + "label": "LSI clock selected", + "value": "06000000" + }, + { + "label": "LSE clock selected", + "value": "07000000" + }, + { + "label": "Internal HSI48 clock selected", + "value": "08000000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MCOPRE", + "label": "Microcontroller clock output prescaler", + "mask": "70000000", + "settings": [ + { + "label": "MCO is divided by 1", + "value": "00000000" + }, + { + "label": "MCO is divided by 2", + "value": "10000000" + }, + { + "label": "MCO is divided by 4", + "value": "20000000" + }, + { + "label": "MCO is divided by 8", + "value": "30000000" + }, + { + "label": "MCO is divided by 16", + "value": "40000000" + } + ] + } + ], + "key": "RCC_CFGR", + "unused": "00000000" + }, + { + "address": "4002100C", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000002", + "key": "PLLSRC", + "label": "Main PLL, PLLSAI1 and PLLSAI2 entry clock source", + "mask": "00000003", + "settings": [ + { + "label": "No clock sent to PLL, PLLSAI1 and PLLSAI2", + "value": "00000000" + }, + { + "label": "MSI clock selected as PLL, PLLSAI1 and PLLSAI2 clock entry", + "value": "00000001" + }, + { + "label": "HSI16 clock selected as PLL, PLLSAI1 and PLLSAI2 clock entry", + "value": "00000002" + }, + { + "label": "HSE clock selected as PLL, PLLSAI1 and PLLSAI2 clock entry", + "value": "00000003" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLM", + "label": "Division factor for the main PLL and audio PLL (PLLSAI1 and PLLSAI2) input clock", + "mask": "00000070", + "settings": [ + { + "label": "PLLM = 1", + "value": "00000000" + }, + { + "label": "PLLM = 2", + "value": "00000010" + }, + { + "label": "PLLM = 3", + "value": "00000020" + }, + { + "label": "PLLM = 4", + "value": "00000030" + }, + { + "label": "PLLM = 5", + "value": "00000040" + }, + { + "label": "PLLM = 6", + "value": "00000050" + }, + { + "label": "PLLM = 7", + "value": "00000060" + }, + { + "label": "PLLM = 8", + "value": "00000070" + } + ] + }, + { + "hidden": false, + "init": "00000a00", + "key": "PLLN", + "label": "Main PLL multiplication factor for VCO", + "mask": "00007F00", + "settings_array": { + "decrease": false, + "disabled_when_zero": false, + "inverted": false, + "max_value": "86", + "min_value": "8" + } + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLPEN", + "label": "Main PLL PLLSAI3CLK output enable", + "mask": "00010000", + "settings": [ + { + "label": "PLLSAI3CLK output disable", + "value": "00000000" + }, + { + "label": "PLLSAI3CLK output enable", + "value": "00010000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLP", + "label": "Main PLL division factor for PLLSAI3CLK (SAI1 and SAI2 clock)", + "mask": "00020000", + "settings": [ + { + "label": "PLLP = 7", + "value": "00000000" + }, + { + "label": "PLLP = 17", + "value": "00020000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLQEN", + "label": "Main PLL PLL48M1CLK output enable", + "mask": "00100000", + "settings": [ + { + "label": "PLL48M1CLK output disable", + "value": "00000000" + }, + { + "label": "PLL48M1CLK output enable", + "value": "00100000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLQ", + "label": "Main PLL division factor for PLL48M1CLK (48 MHz clock)", + "mask": "00600000", + "settings": [ + { + "label": "PLLQ = 2", + "value": "00000000" + }, + { + "label": "PLLQ = 4", + "value": "00200000" + }, + { + "label": "PLLQ = 6", + "value": "00400000" + }, + { + "label": "PLLQ = 8", + "value": "00600000" + } + ] + }, + { + "hidden": false, + "init": "01000000", + "key": "PLLREN", + "label": "Main PLL PLLCLK output enable", + "mask": "01000000", + "settings": [ + { + "label": "PLLCLK output disable", + "value": "00000000" + }, + { + "label": "PLLCLK output enable", + "value": "01000000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLR", + "label": "Main PLL division factor for PLLCLK (system clock)", + "mask": "06000000", + "settings": [ + { + "label": "PLLR = 2", + "value": "00000000" + }, + { + "label": "PLLR = 4", + "value": "02000000" + }, + { + "label": "PLLR = 6", + "value": "04000000" + }, + { + "label": "PLLR = 8", + "value": "06000000" + } + ] + } + ], + "key": "RCC_PLLCFGR", + "unused": "00000000" + }, + { + "address": "40021094", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "LSION", + "label": "LSI oscillator enable", + "mask": "00000001", + "settings": [ + { + "label": "LSI oscillator OFF", + "value": "00000000" + }, + { + "label": "LSI oscillator ON", + "value": "00000001" + } + ] + }, + { + "hidden": false, + "init": "00000600", + "key": "MSISRANGE", + "label": "MSI range after Standby mode (RCC_CSR)", + "mask": "00000F00", + "settings": [ + { + "label": "Range 4 around 1 MHz", + "value": "00000400" + }, + { + "label": "Range 5 around 2 MHz", + "value": "00000500" + }, + { + "label": "Range 6 around 4 MHz (reset value)", + "value": "00000600" + }, + { + "label": "Range 7 around 8 MHz", + "value": "00000700" + } + ] + } + ], + "key": "RCC_CSR", + "unused": "00000000" + }, + { + "address": "40007000", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000200", + "key": "VCORE", + "label": "Core Voltage", + "mask": "00000600", + "settings": [ + { + "label": "VCORE = 1.2 V", + "value": "00000200" + }, + { + "label": "VCORE = 1.0 V", + "value": "00000400" + } + ] + } + ], + "key": "PWR_CR1", + "unused": "00000000" + }, + { + "address": "40021098", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "HSI48ON", + "label": "48MHz HSI clock enable bit", + "mask": "00000001", + "settings": [ + { + "label": "48MHz HSI clock disabled", + "value": "00000000" + }, + { + "label": "48MHz HSI clock enabled", + "value": "00000001" + } + ] + } + ], + "key": "RCC_CRRCR", + "unused": "00000000" + }, + { + "address": "40021088", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "CLK48SEL", + "label": "48 MHz clock source selection", + "mask": "0C000000", + "settings": [ + { + "label": "HSI48 clock selected as 48 MHz clock", + "value": "00000000" + }, + { + "label": "PLL48M2CLK selected as 48 MHz clock", + "value": "04000000" + }, + { + "label": "PLL48M1CLK selected as 48 MHz clock", + "value": "08000000" + }, + { + "label": "MSI clock selected as 48 MHz clock", + "value": "0C000000" + } + ] + } + ], + "key": "RCC_CCIPR", + "unused": "00000000" + } + ], + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "mcu": "STM32L422RB", + "clock": 80 +} diff --git a/ARM/gcc_clang/def/STM32L422TB.json b/ARM/gcc_clang/def/STM32L422TB.json new file mode 100644 index 000000000..2ddf590c2 --- /dev/null +++ b/ARM/gcc_clang/def/STM32L422TB.json @@ -0,0 +1,826 @@ +{ + "config_registers": [ + { + "address": "40021000", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "MSION", + "label": "MSI clock enable", + "mask": "00000001", + "settings": [ + { + "label": "MSI oscillator OFF", + "value": "00000000" + }, + { + "label": "MSI oscillator ON", + "value": "00000001" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MSIPLLEN", + "label": "MSI clock PLL enable", + "mask": "00000004", + "settings": [ + { + "label": "MSI PLL OFF", + "value": "00000000" + }, + { + "label": "MSI PLL ON", + "value": "00000004" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MSIRGSEL", + "label": "MSI clock range selection", + "mask": "00000008", + "settings": [ + { + "label": "MSI Range is provided in RCC_CSR register", + "value": "00000000" + }, + { + "label": "MSI Range is provided in RCC_CR register", + "value": "00000008" + } + ] + }, + { + "hidden": false, + "init": "00000060", + "key": "MSIRANGE", + "label": "MSI clock ranges in RCC_CR register", + "mask": "000000F0", + "settings": [ + { + "label": "range 0 around 100 kHz", + "value": "00000000" + }, + { + "label": "range 1 around 200 kHz", + "value": "00000010" + }, + { + "label": "range 2 around 400 kHz", + "value": "00000020" + }, + { + "label": "range 3 around 800 kHz", + "value": "00000030" + }, + { + "label": "range 4 around 1MHz", + "value": "00000040" + }, + { + "label": "range 5 around 2MHz", + "value": "00000050" + }, + { + "label": "range 6 around 4MHz", + "value": "00000060" + }, + { + "label": "range 7 around 8MHz", + "value": "00000070" + }, + { + "label": "range 8 around 16MHz", + "value": "00000080" + }, + { + "label": "range 9 around 24MHz", + "value": "00000090" + }, + { + "label": "range 10 around 32MHz", + "value": "000000A0" + }, + { + "label": "range 11 around 48MHz", + "value": "000000B0" + } + ] + }, + { + "hidden": false, + "init": "00000100", + "key": "HSION", + "label": "HSI clock enable", + "mask": "00000100", + "settings": [ + { + "label": "HSI16 oscillator OFF", + "value": "00000000" + }, + { + "label": "HSI16 oscillator ON", + "value": "00000100" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HSIKERON", + "label": "HSI16 always enable for peripheral kernels", + "mask": "00000200", + "settings": [ + { + "label": "No effect on HSI16 oscillator", + "value": "00000000" + }, + { + "label": "HSI16 oscillator is forced ON even in Stop mode", + "value": "00000200" + } + ] + }, + { + "hidden": false, + "init": "00000800", + "key": "HSIASFS", + "label": "HSI16 automatic start from Stop", + "mask": "00000800", + "settings": [ + { + "label": "HSI16 oscillator is not enabled by hardware when exiting Stop mode with MSI as wakeup clock", + "value": "00000000" + }, + { + "label": "HSI16 oscillator is enabled by hardware when exiting Stop mode with MSI as wakeup clock", + "value": "00000800" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HSEON", + "label": "HSE clock enable", + "mask": "00010000", + "settings": [ + { + "label": "HSE oscillator OFF", + "value": "00000000" + }, + { + "label": "HSE oscillator ON", + "value": "00010000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HSEBYP", + "label": "HSE crystal oscillator bypass", + "mask": "00040000", + "settings": [ + { + "label": "HSE crystal oscillator not bypassed", + "value": "00000000" + }, + { + "label": "HSE crystal oscillator bypassed with external clock", + "value": "00040000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "CSSON", + "label": "Clock security system enable", + "mask": "00080000", + "settings": [ + { + "label": "Clock security system OFF", + "value": "00000000" + }, + { + "label": "Clock security system ON", + "value": "00080000" + } + ] + }, + { + "hidden": false, + "init": "01000000", + "key": "PLLON", + "label": "Main PLL enable", + "mask": "01000000", + "settings": [ + { + "label": "PLL OFF", + "value": "00000000" + }, + { + "label": "PLL ON", + "value": "01000000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLSAI1ON", + "label": "SAI1 PLL enable", + "mask": "04000000", + "settings": [ + { + "label": "PLLSAI1 OFF", + "value": "00000000" + }, + { + "label": "PLLSAI1 ON", + "value": "04000000" + } + ] + } + ], + "key": "RCC_CR", + "unused": "00000000" + }, + { + "address": "40021008", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000003", + "key": "SW", + "label": "System clock switch", + "mask": "00000003", + "settings": [ + { + "label": "MSI selected as system clock", + "value": "00000000" + }, + { + "label": "HSI16 selected as system clock", + "value": "00000001" + }, + { + "label": "HSE selected as system clock", + "value": "00000002" + }, + { + "label": "PLL selected as system clock", + "value": "00000003" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "HPRE", + "label": "Set and cleared by software to control the division factor of the AHB clock", + "mask": "000000F0", + "settings": [ + { + "label": "SYSCLK not divided", + "value": "00000000" + }, + { + "label": "SYSCLK divided by 2", + "value": "00000080" + }, + { + "label": "SYSCLK divided by 4", + "value": "00000090" + }, + { + "label": "SYSCLK divided by 8", + "value": "000000A0" + }, + { + "label": "SYSCLK divided by 16", + "value": "000000B0" + }, + { + "label": "SYSCLK divided by 64", + "value": "000000C0" + }, + { + "label": "SYSCLK divided by 128", + "value": "000000D0" + }, + { + "label": "SYSCLK divided by 256", + "value": "000000E0" + }, + { + "label": "SYSCLK divided by 512", + "value": "000000F0" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PPRE1", + "label": "APB low-speed prescaler (APB1)", + "mask": "00000700", + "settings": [ + { + "label": "HCLK not divided ", + "value": "00000000" + }, + { + "label": "HCLK divided by 2 ", + "value": "00000400" + }, + { + "label": "HCLK divided by 4 ", + "value": "00000500" + }, + { + "label": "HCLK divided by 8 ", + "value": "00000600" + }, + { + "label": "HCLK divided by 16 ", + "value": "00000700" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PPRE2", + "label": "APB high-speed prescaler (APB2)", + "mask": "00003800", + "settings": [ + { + "label": "HCLK not divided ", + "value": "00000000" + }, + { + "label": "HCLK divided by 2 ", + "value": "00002000" + }, + { + "label": "HCLK divided by 4 ", + "value": "00002800" + }, + { + "label": "HCLK divided by 8 ", + "value": "00003000" + }, + { + "label": "HCLK divided by 16 ", + "value": "00003800" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "STOPWUCK", + "label": "Wakeup from Stop and CSS backup clock selection", + "mask": "00008000", + "settings": [ + { + "label": "MSI oscillator selected as wakeup from stop clock and CSS backup clock", + "value": "00000000" + }, + { + "label": "HSI16 oscillator selected as wakeup from stop clock and CSS backup clock", + "value": "00008000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MCOSEL", + "label": "Microcontroller clock output", + "mask": "0F000000", + "settings": [ + { + "label": "MCO output disabled, no clock on MCO", + "value": "00000000" + }, + { + "label": "SYSCLK system clock selected", + "value": "01000000" + }, + { + "label": "MSI clock selected", + "value": "02000000" + }, + { + "label": "HSI16 clock selected", + "value": "03000000" + }, + { + "label": "HSE clock selected", + "value": "04000000" + }, + { + "label": "Main PLL clock selected", + "value": "05000000" + }, + { + "label": "LSI clock selected", + "value": "06000000" + }, + { + "label": "LSE clock selected", + "value": "07000000" + }, + { + "label": "Internal HSI48 clock selected", + "value": "08000000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "MCOPRE", + "label": "Microcontroller clock output prescaler", + "mask": "70000000", + "settings": [ + { + "label": "MCO is divided by 1", + "value": "00000000" + }, + { + "label": "MCO is divided by 2", + "value": "10000000" + }, + { + "label": "MCO is divided by 4", + "value": "20000000" + }, + { + "label": "MCO is divided by 8", + "value": "30000000" + }, + { + "label": "MCO is divided by 16", + "value": "40000000" + } + ] + } + ], + "key": "RCC_CFGR", + "unused": "00000000" + }, + { + "address": "4002100C", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000002", + "key": "PLLSRC", + "label": "Main PLL, PLLSAI1 and PLLSAI2 entry clock source", + "mask": "00000003", + "settings": [ + { + "label": "No clock sent to PLL, PLLSAI1 and PLLSAI2", + "value": "00000000" + }, + { + "label": "MSI clock selected as PLL, PLLSAI1 and PLLSAI2 clock entry", + "value": "00000001" + }, + { + "label": "HSI16 clock selected as PLL, PLLSAI1 and PLLSAI2 clock entry", + "value": "00000002" + }, + { + "label": "HSE clock selected as PLL, PLLSAI1 and PLLSAI2 clock entry", + "value": "00000003" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLM", + "label": "Division factor for the main PLL and audio PLL (PLLSAI1 and PLLSAI2) input clock", + "mask": "00000070", + "settings": [ + { + "label": "PLLM = 1", + "value": "00000000" + }, + { + "label": "PLLM = 2", + "value": "00000010" + }, + { + "label": "PLLM = 3", + "value": "00000020" + }, + { + "label": "PLLM = 4", + "value": "00000030" + }, + { + "label": "PLLM = 5", + "value": "00000040" + }, + { + "label": "PLLM = 6", + "value": "00000050" + }, + { + "label": "PLLM = 7", + "value": "00000060" + }, + { + "label": "PLLM = 8", + "value": "00000070" + } + ] + }, + { + "hidden": false, + "init": "00000a00", + "key": "PLLN", + "label": "Main PLL multiplication factor for VCO", + "mask": "00007F00", + "settings_array": { + "decrease": false, + "disabled_when_zero": false, + "inverted": false, + "max_value": "86", + "min_value": "8" + } + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLPEN", + "label": "Main PLL PLLSAI3CLK output enable", + "mask": "00010000", + "settings": [ + { + "label": "PLLSAI3CLK output disable", + "value": "00000000" + }, + { + "label": "PLLSAI3CLK output enable", + "value": "00010000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLP", + "label": "Main PLL division factor for PLLSAI3CLK (SAI1 and SAI2 clock)", + "mask": "00020000", + "settings": [ + { + "label": "PLLP = 7", + "value": "00000000" + }, + { + "label": "PLLP = 17", + "value": "00020000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLQEN", + "label": "Main PLL PLL48M1CLK output enable", + "mask": "00100000", + "settings": [ + { + "label": "PLL48M1CLK output disable", + "value": "00000000" + }, + { + "label": "PLL48M1CLK output enable", + "value": "00100000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLQ", + "label": "Main PLL division factor for PLL48M1CLK (48 MHz clock)", + "mask": "00600000", + "settings": [ + { + "label": "PLLQ = 2", + "value": "00000000" + }, + { + "label": "PLLQ = 4", + "value": "00200000" + }, + { + "label": "PLLQ = 6", + "value": "00400000" + }, + { + "label": "PLLQ = 8", + "value": "00600000" + } + ] + }, + { + "hidden": false, + "init": "01000000", + "key": "PLLREN", + "label": "Main PLL PLLCLK output enable", + "mask": "01000000", + "settings": [ + { + "label": "PLLCLK output disable", + "value": "00000000" + }, + { + "label": "PLLCLK output enable", + "value": "01000000" + } + ] + }, + { + "hidden": false, + "init": "00000000", + "key": "PLLR", + "label": "Main PLL division factor for PLLCLK (system clock)", + "mask": "06000000", + "settings": [ + { + "label": "PLLR = 2", + "value": "00000000" + }, + { + "label": "PLLR = 4", + "value": "02000000" + }, + { + "label": "PLLR = 6", + "value": "04000000" + }, + { + "label": "PLLR = 8", + "value": "06000000" + } + ] + } + ], + "key": "RCC_PLLCFGR", + "unused": "00000000" + }, + { + "address": "40021094", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "LSION", + "label": "LSI oscillator enable", + "mask": "00000001", + "settings": [ + { + "label": "LSI oscillator OFF", + "value": "00000000" + }, + { + "label": "LSI oscillator ON", + "value": "00000001" + } + ] + }, + { + "hidden": false, + "init": "00000600", + "key": "MSISRANGE", + "label": "MSI range after Standby mode (RCC_CSR)", + "mask": "00000F00", + "settings": [ + { + "label": "Range 4 around 1 MHz", + "value": "00000400" + }, + { + "label": "Range 5 around 2 MHz", + "value": "00000500" + }, + { + "label": "Range 6 around 4 MHz (reset value)", + "value": "00000600" + }, + { + "label": "Range 7 around 8 MHz", + "value": "00000700" + } + ] + } + ], + "key": "RCC_CSR", + "unused": "00000000" + }, + { + "address": "40007000", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000200", + "key": "VCORE", + "label": "Core Voltage", + "mask": "00000600", + "settings": [ + { + "label": "VCORE = 1.2 V", + "value": "00000200" + }, + { + "label": "VCORE = 1.0 V", + "value": "00000400" + } + ] + } + ], + "key": "PWR_CR1", + "unused": "00000000" + }, + { + "address": "40021098", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "HSI48ON", + "label": "48MHz HSI clock enable bit", + "mask": "00000001", + "settings": [ + { + "label": "48MHz HSI clock disabled", + "value": "00000000" + }, + { + "label": "48MHz HSI clock enabled", + "value": "00000001" + } + ] + } + ], + "key": "RCC_CRRCR", + "unused": "00000000" + }, + { + "address": "40021088", + "default": "00000000", + "fields": [ + { + "hidden": false, + "init": "00000000", + "key": "CLK48SEL", + "label": "48 MHz clock source selection", + "mask": "0C000000", + "settings": [ + { + "label": "HSI48 clock selected as 48 MHz clock", + "value": "00000000" + }, + { + "label": "PLL48M2CLK selected as 48 MHz clock", + "value": "04000000" + }, + { + "label": "PLL48M1CLK selected as 48 MHz clock", + "value": "08000000" + }, + { + "label": "MSI clock selected as 48 MHz clock", + "value": "0C000000" + } + ] + } + ], + "key": "RCC_CCIPR", + "unused": "00000000" + } + ], + "core": "M4EF", + "delay_src_path": "delays/m4ef/__lib_delays.c", + "mcu": "STM32L422TB", + "clock": 80 +} diff --git a/ARM/gcc_clang/def/stm/STM32L422RB/mcu.h b/ARM/gcc_clang/def/stm/STM32L422RB/mcu.h new file mode 100644 index 000000000..20261992e --- /dev/null +++ b/ARM/gcc_clang/def/stm/STM32L422RB/mcu.h @@ -0,0 +1,11153 @@ +/** + ****************************************************************************** + * @file stm32l422xx.h + * @author MCD Application Team + * @brief CMSIS STM32L422xx Device Peripheral Access Layer Header File. + * + * This file contains: + * - Data structures and the address mapping for all peripherals + * - Peripheral's registers declarations and bits definition + * - Macros to access peripheral's registers hardware + * + ****************************************************************************** + * @attention + * + * Copyright (c) 2017 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +/** @addtogroup CMSIS_Device + * @{ + */ + +/** @addtogroup stm32l422xx + * @{ + */ + +#ifndef __STM32L422xx_H +#define __STM32L422xx_H + +#ifdef __cplusplus + extern "C" { +#endif /* __cplusplus */ + +/** @addtogroup Configuration_section_for_CMSIS + * @{ + */ + +/** + * @brief Configuration of the Cortex-M4 Processor and Core Peripherals + */ +#define __CM4_REV 0x0001U /*!< Cortex-M4 revision r0p1 */ +#define __MPU_PRESENT 1U /*!< STM32L4XX provides an MPU */ +#define __NVIC_PRIO_BITS 4U /*!< STM32L4XX uses 4 Bits for the Priority Levels */ +#define __Vendor_SysTickConfig 0U /*!< Set to 1 if different SysTick Config is used */ +#define __FPU_PRESENT 1U /*!< FPU present */ + +/** + * @} + */ + +/** @addtogroup Peripheral_interrupt_number_definition + * @{ + */ + +/** + * @brief STM32L4XX Interrupt Number Definition, according to the selected device + * in @ref Library_configuration_section + */ +typedef enum +{ +/****** Cortex-M4 Processor Exceptions Numbers ****************************************************************/ + NonMaskableInt_IRQn = -14, /*!< 2 Cortex-M4 Non Maskable Interrupt */ + HardFault_IRQn = -13, /*!< 3 Cortex-M4 Hard Fault Interrupt */ + MemoryManagement_IRQn = -12, /*!< 4 Cortex-M4 Memory Management Interrupt */ + BusFault_IRQn = -11, /*!< 5 Cortex-M4 Bus Fault Interrupt */ + UsageFault_IRQn = -10, /*!< 6 Cortex-M4 Usage Fault Interrupt */ + SVCall_IRQn = -5, /*!< 11 Cortex-M4 SV Call Interrupt */ + DebugMonitor_IRQn = -4, /*!< 12 Cortex-M4 Debug Monitor Interrupt */ + PendSV_IRQn = -2, /*!< 14 Cortex-M4 Pend SV Interrupt */ + SysTick_IRQn = -1, /*!< 15 Cortex-M4 System Tick Interrupt */ +/****** STM32 specific Interrupt Numbers **********************************************************************/ + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_PVM_IRQn = 1, /*!< PVD/PVM1/PVM3/PVM4 through EXTI Line detection Interrupts */ + TAMP_STAMP_IRQn = 2, /*!< Tamper and TimeStamp interrupts through the EXTI line */ + RTC_WKUP_IRQn = 3, /*!< RTC Wakeup interrupt through the EXTI line */ + FLASH_IRQn = 4, /*!< FLASH global Interrupt */ + RCC_IRQn = 5, /*!< RCC global Interrupt */ + EXTI0_IRQn = 6, /*!< EXTI Line0 Interrupt */ + EXTI1_IRQn = 7, /*!< EXTI Line1 Interrupt */ + EXTI2_IRQn = 8, /*!< EXTI Line2 Interrupt */ + EXTI3_IRQn = 9, /*!< EXTI Line3 Interrupt */ + EXTI4_IRQn = 10, /*!< EXTI Line4 Interrupt */ + DMA1_Channel1_IRQn = 11, /*!< DMA1 Channel 1 global Interrupt */ + DMA1_Channel2_IRQn = 12, /*!< DMA1 Channel 2 global Interrupt */ + DMA1_Channel3_IRQn = 13, /*!< DMA1 Channel 3 global Interrupt */ + DMA1_Channel4_IRQn = 14, /*!< DMA1 Channel 4 global Interrupt */ + DMA1_Channel5_IRQn = 15, /*!< DMA1 Channel 5 global Interrupt */ + DMA1_Channel6_IRQn = 16, /*!< DMA1 Channel 6 global Interrupt */ + DMA1_Channel7_IRQn = 17, /*!< DMA1 Channel 7 global Interrupt */ + ADC1_2_IRQn = 18, /*!< ADC1, ADC2 SAR global Interrupts */ + EXTI9_5_IRQn = 23, /*!< External Line[9:5] Interrupts */ + TIM1_BRK_TIM15_IRQn = 24, /*!< TIM1 Break interrupt and TIM15 global interrupt */ + TIM1_UP_TIM16_IRQn = 25, /*!< TIM1 Update Interrupt and TIM16 global interrupt */ + TIM1_TRG_COM_IRQn = 26, /*!< TIM1 Trigger and Commutation Interrupt */ + TIM1_CC_IRQn = 27, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 28, /*!< TIM2 global Interrupt */ + I2C1_EV_IRQn = 31, /*!< I2C1 Event Interrupt */ + I2C1_ER_IRQn = 32, /*!< I2C1 Error Interrupt */ + I2C2_EV_IRQn = 33, /*!< I2C2 Event Interrupt */ + I2C2_ER_IRQn = 34, /*!< I2C2 Error Interrupt */ + SPI1_IRQn = 35, /*!< SPI1 global Interrupt */ + SPI2_IRQn = 36, /*!< SPI2 global Interrupt */ + USART1_IRQn = 37, /*!< USART1 global Interrupt */ + USART2_IRQn = 38, /*!< USART2 global Interrupt */ + USART3_IRQn = 39, /*!< USART3 global Interrupt */ + EXTI15_10_IRQn = 40, /*!< External Line[15:10] Interrupts */ + RTC_Alarm_IRQn = 41, /*!< RTC Alarm (A and B) through EXTI Line Interrupt */ + TIM6_IRQn = 54, /*!< TIM6 global interrupt */ + DMA2_Channel1_IRQn = 56, /*!< DMA2 Channel 1 global Interrupt */ + DMA2_Channel2_IRQn = 57, /*!< DMA2 Channel 2 global Interrupt */ + DMA2_Channel3_IRQn = 58, /*!< DMA2 Channel 3 global Interrupt */ + DMA2_Channel4_IRQn = 59, /*!< DMA2 Channel 4 global Interrupt */ + DMA2_Channel5_IRQn = 60, /*!< DMA2 Channel 5 global Interrupt */ + COMP_IRQn = 64, /*!< COMP1 Interrupt */ + LPTIM1_IRQn = 65, /*!< LP TIM1 interrupt */ + LPTIM2_IRQn = 66, /*!< LP TIM2 interrupt */ + USB_IRQn = 67, /*!< USB event Interrupt */ + DMA2_Channel6_IRQn = 68, /*!< DMA2 Channel 6 global interrupt */ + DMA2_Channel7_IRQn = 69, /*!< DMA2 Channel 7 global interrupt */ + LPUART1_IRQn = 70, /*!< LP UART1 interrupt */ + QUADSPI_IRQn = 71, /*!< Quad SPI global interrupt */ + I2C3_EV_IRQn = 72, /*!< I2C3 event interrupt */ + I2C3_ER_IRQn = 73, /*!< I2C3 error interrupt */ + TSC_IRQn = 77, /*!< Touch Sense Controller global interrupt */ + AES_IRQn = 79, /*!< AES global interrupt */ + RNG_IRQn = 80, /*!< RNG global interrupt */ + FPU_IRQn = 81, /*!< FPU global interrupt */ + CRS_IRQn = 82 /*!< CRS global interrupt */ +} IRQn_Type; + +/** + * @} + */ + +// Note: Changed for MikroE implementation. +// #include "core_cm4.h" /* Cortex-M4 processor and core peripherals */ +// Note: Changed for MikroE implementation. +// #include "system_stm32l4xx.h" +#include +#define __I volatile // Note: Added for MikroE implementation. +#define __O __I // Note: Added for MikroE implementation. +#define __IO __I // Note: Added for MikroE implementation. + +/** @addtogroup Peripheral_registers_structures + * @{ + */ + +/** + * @brief Analog to Digital Converter + */ + +typedef struct +{ + __IO uint32_t ISR; /*!< ADC interrupt and status register, Address offset: 0x00 */ + __IO uint32_t IER; /*!< ADC interrupt enable register, Address offset: 0x04 */ + __IO uint32_t CR; /*!< ADC control register, Address offset: 0x08 */ + __IO uint32_t CFGR; /*!< ADC configuration register 1, Address offset: 0x0C */ + __IO uint32_t CFGR2; /*!< ADC configuration register 2, Address offset: 0x10 */ + __IO uint32_t SMPR1; /*!< ADC sampling time register 1, Address offset: 0x14 */ + __IO uint32_t SMPR2; /*!< ADC sampling time register 2, Address offset: 0x18 */ + uint32_t RESERVED1; /*!< Reserved, 0x1C */ + __IO uint32_t TR1; /*!< ADC analog watchdog 1 threshold register, Address offset: 0x20 */ + __IO uint32_t TR2; /*!< ADC analog watchdog 2 threshold register, Address offset: 0x24 */ + __IO uint32_t TR3; /*!< ADC analog watchdog 3 threshold register, Address offset: 0x28 */ + uint32_t RESERVED2; /*!< Reserved, 0x2C */ + __IO uint32_t SQR1; /*!< ADC group regular sequencer register 1, Address offset: 0x30 */ + __IO uint32_t SQR2; /*!< ADC group regular sequencer register 2, Address offset: 0x34 */ + __IO uint32_t SQR3; /*!< ADC group regular sequencer register 3, Address offset: 0x38 */ + __IO uint32_t SQR4; /*!< ADC group regular sequencer register 4, Address offset: 0x3C */ + __IO uint32_t DR; /*!< ADC group regular data register, Address offset: 0x40 */ + uint32_t RESERVED3; /*!< Reserved, 0x44 */ + uint32_t RESERVED4; /*!< Reserved, 0x48 */ + __IO uint32_t JSQR; /*!< ADC group injected sequencer register, Address offset: 0x4C */ + uint32_t RESERVED5[4]; /*!< Reserved, 0x50 - 0x5C */ + __IO uint32_t OFR1; /*!< ADC offset register 1, Address offset: 0x60 */ + __IO uint32_t OFR2; /*!< ADC offset register 2, Address offset: 0x64 */ + __IO uint32_t OFR3; /*!< ADC offset register 3, Address offset: 0x68 */ + __IO uint32_t OFR4; /*!< ADC offset register 4, Address offset: 0x6C */ + uint32_t RESERVED6[4]; /*!< Reserved, 0x70 - 0x7C */ + __IO uint32_t JDR1; /*!< ADC group injected rank 1 data register, Address offset: 0x80 */ + __IO uint32_t JDR2; /*!< ADC group injected rank 2 data register, Address offset: 0x84 */ + __IO uint32_t JDR3; /*!< ADC group injected rank 3 data register, Address offset: 0x88 */ + __IO uint32_t JDR4; /*!< ADC group injected rank 4 data register, Address offset: 0x8C */ + uint32_t RESERVED7[4]; /*!< Reserved, 0x090 - 0x09C */ + __IO uint32_t AWD2CR; /*!< ADC analog watchdog 1 configuration register, Address offset: 0xA0 */ + __IO uint32_t AWD3CR; /*!< ADC analog watchdog 3 Configuration Register, Address offset: 0xA4 */ + uint32_t RESERVED8; /*!< Reserved, 0x0A8 */ + uint32_t RESERVED9; /*!< Reserved, 0x0AC */ + __IO uint32_t DIFSEL; /*!< ADC differential mode selection register, Address offset: 0xB0 */ + __IO uint32_t CALFACT; /*!< ADC calibration factors, Address offset: 0xB4 */ + +} ADC_TypeDef; + +typedef struct +{ + __IO uint32_t CSR; /*!< ADC common status register, Address offset: ADC1 base address + 0x300 */ + uint32_t RESERVED; /*!< Reserved, Address offset: ADC1 base address + 0x304 */ + __IO uint32_t CCR; /*!< ADC common configuration register, Address offset: ADC1 base address + 0x308 */ + __IO uint32_t CDR; /*!< ADC common group regular data register Address offset: ADC1 base address + 0x30C */ +} ADC_Common_TypeDef; + + + + +/** + * @brief Comparator + */ + +typedef struct +{ + __IO uint32_t CSR; /*!< COMP control and status register, Address offset: 0x00 */ +} COMP_TypeDef; + +typedef struct +{ + __IO uint32_t CSR; /*!< COMP control and status register, used for bits common to several COMP instances, Address offset: 0x00 */ +} COMP_Common_TypeDef; + +/** + * @brief CRC calculation unit + */ + +typedef struct +{ + __IO uint32_t DR; /*!< CRC Data register, Address offset: 0x00 */ + __IO uint8_t IDR; /*!< CRC Independent data register, Address offset: 0x04 */ + uint8_t RESERVED0; /*!< Reserved, 0x05 */ + uint16_t RESERVED1; /*!< Reserved, 0x06 */ + __IO uint32_t CR; /*!< CRC Control register, Address offset: 0x08 */ + uint32_t RESERVED2; /*!< Reserved, 0x0C */ + __IO uint32_t INIT; /*!< Initial CRC value register, Address offset: 0x10 */ + __IO uint32_t POL; /*!< CRC polynomial register, Address offset: 0x14 */ +} CRC_TypeDef; + +/** + * @brief Clock Recovery System + */ +typedef struct +{ +__IO uint32_t CR; /*!< CRS ccontrol register, Address offset: 0x00 */ +__IO uint32_t CFGR; /*!< CRS configuration register, Address offset: 0x04 */ +__IO uint32_t ISR; /*!< CRS interrupt and status register, Address offset: 0x08 */ +__IO uint32_t ICR; /*!< CRS interrupt flag clear register, Address offset: 0x0C */ +} CRS_TypeDef; + + + +/** + * @brief Debug MCU + */ + +typedef struct +{ + __IO uint32_t IDCODE; /*!< MCU device ID code, Address offset: 0x00 */ + __IO uint32_t CR; /*!< Debug MCU configuration register, Address offset: 0x04 */ + __IO uint32_t APB1FZR1; /*!< Debug MCU APB1 freeze register 1, Address offset: 0x08 */ + __IO uint32_t APB1FZR2; /*!< Debug MCU APB1 freeze register 2, Address offset: 0x0C */ + __IO uint32_t APB2FZ; /*!< Debug MCU APB2 freeze register, Address offset: 0x10 */ +} DBGMCU_TypeDef; + + +/** + * @brief DMA Controller + */ + +typedef struct +{ + __IO uint32_t CCR; /*!< DMA channel x configuration register */ + __IO uint32_t CNDTR; /*!< DMA channel x number of data register */ + __IO uint32_t CPAR; /*!< DMA channel x peripheral address register */ + __IO uint32_t CMAR; /*!< DMA channel x memory address register */ +} DMA_Channel_TypeDef; + +typedef struct +{ + __IO uint32_t ISR; /*!< DMA interrupt status register, Address offset: 0x00 */ + __IO uint32_t IFCR; /*!< DMA interrupt flag clear register, Address offset: 0x04 */ +} DMA_TypeDef; + +typedef struct +{ + __IO uint32_t CSELR; /*!< DMA channel selection register */ +} DMA_Request_TypeDef; + +/* Legacy define */ +#define DMA_request_TypeDef DMA_Request_TypeDef + + +/** + * @brief External Interrupt/Event Controller + */ + +typedef struct +{ + __IO uint32_t IMR1; /*!< EXTI Interrupt mask register 1, Address offset: 0x00 */ + __IO uint32_t EMR1; /*!< EXTI Event mask register 1, Address offset: 0x04 */ + __IO uint32_t RTSR1; /*!< EXTI Rising trigger selection register 1, Address offset: 0x08 */ + __IO uint32_t FTSR1; /*!< EXTI Falling trigger selection register 1, Address offset: 0x0C */ + __IO uint32_t SWIER1; /*!< EXTI Software interrupt event register 1, Address offset: 0x10 */ + __IO uint32_t PR1; /*!< EXTI Pending register 1, Address offset: 0x14 */ + uint32_t RESERVED1; /*!< Reserved, 0x18 */ + uint32_t RESERVED2; /*!< Reserved, 0x1C */ + __IO uint32_t IMR2; /*!< EXTI Interrupt mask register 2, Address offset: 0x20 */ + __IO uint32_t EMR2; /*!< EXTI Event mask register 2, Address offset: 0x24 */ + __IO uint32_t RTSR2; /*!< EXTI Rising trigger selection register 2, Address offset: 0x28 */ + __IO uint32_t FTSR2; /*!< EXTI Falling trigger selection register 2, Address offset: 0x2C */ + __IO uint32_t SWIER2; /*!< EXTI Software interrupt event register 2, Address offset: 0x30 */ + __IO uint32_t PR2; /*!< EXTI Pending register 2, Address offset: 0x34 */ +} EXTI_TypeDef; + + +/** + * @brief Firewall + */ + +typedef struct +{ + __IO uint32_t CSSA; /*!< Code Segment Start Address register, Address offset: 0x00 */ + __IO uint32_t CSL; /*!< Code Segment Length register, Address offset: 0x04 */ + __IO uint32_t NVDSSA; /*!< NON volatile data Segment Start Address register, Address offset: 0x08 */ + __IO uint32_t NVDSL; /*!< NON volatile data Segment Length register, Address offset: 0x0C */ + __IO uint32_t VDSSA ; /*!< Volatile data Segment Start Address register, Address offset: 0x10 */ + __IO uint32_t VDSL ; /*!< Volatile data Segment Length register, Address offset: 0x14 */ + uint32_t RESERVED1; /*!< Reserved1, Address offset: 0x18 */ + uint32_t RESERVED2; /*!< Reserved2, Address offset: 0x1C */ + __IO uint32_t CR ; /*!< Configuration register, Address offset: 0x20 */ +} FIREWALL_TypeDef; + + +/** + * @brief FLASH Registers + */ + +typedef struct +{ + __IO uint32_t ACR; /*!< FLASH access control register, Address offset: 0x00 */ + __IO uint32_t PDKEYR; /*!< FLASH power down key register, Address offset: 0x04 */ + __IO uint32_t KEYR; /*!< FLASH key register, Address offset: 0x08 */ + __IO uint32_t OPTKEYR; /*!< FLASH option key register, Address offset: 0x0C */ + __IO uint32_t SR; /*!< FLASH status register, Address offset: 0x10 */ + __IO uint32_t CR; /*!< FLASH control register, Address offset: 0x14 */ + __IO uint32_t ECCR; /*!< FLASH ECC register, Address offset: 0x18 */ + __IO uint32_t RESERVED1; /*!< Reserved1, Address offset: 0x1C */ + __IO uint32_t OPTR; /*!< FLASH option register, Address offset: 0x20 */ + __IO uint32_t PCROP1SR; /*!< FLASH bank1 PCROP start address register, Address offset: 0x24 */ + __IO uint32_t PCROP1ER; /*!< FLASH bank1 PCROP end address register, Address offset: 0x28 */ + __IO uint32_t WRP1AR; /*!< FLASH bank1 WRP area A address register, Address offset: 0x2C */ + __IO uint32_t WRP1BR; /*!< FLASH bank1 WRP area B address register, Address offset: 0x30 */ +} FLASH_TypeDef; + + + +/** + * @brief General Purpose I/O + */ + +typedef struct +{ + __IO uint32_t MODER; /*!< GPIO port mode register, Address offset: 0x00 */ + __IO uint32_t OTYPER; /*!< GPIO port output type register, Address offset: 0x04 */ + __IO uint32_t OSPEEDR; /*!< GPIO port output speed register, Address offset: 0x08 */ + __IO uint32_t PUPDR; /*!< GPIO port pull-up/pull-down register, Address offset: 0x0C */ + __IO uint32_t IDR; /*!< GPIO port input data register, Address offset: 0x10 */ + __IO uint32_t ODR; /*!< GPIO port output data register, Address offset: 0x14 */ + __IO uint32_t BSRR; /*!< GPIO port bit set/reset register, Address offset: 0x18 */ + __IO uint32_t LCKR; /*!< GPIO port configuration lock register, Address offset: 0x1C */ + __IO uint32_t AFR[2]; /*!< GPIO alternate function registers, Address offset: 0x20-0x24 */ + __IO uint32_t BRR; /*!< GPIO Bit Reset register, Address offset: 0x28 */ + +} GPIO_TypeDef; + + +/** + * @brief Inter-integrated Circuit Interface + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< I2C Control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< I2C Control register 2, Address offset: 0x04 */ + __IO uint32_t OAR1; /*!< I2C Own address 1 register, Address offset: 0x08 */ + __IO uint32_t OAR2; /*!< I2C Own address 2 register, Address offset: 0x0C */ + __IO uint32_t TIMINGR; /*!< I2C Timing register, Address offset: 0x10 */ + __IO uint32_t TIMEOUTR; /*!< I2C Timeout register, Address offset: 0x14 */ + __IO uint32_t ISR; /*!< I2C Interrupt and status register, Address offset: 0x18 */ + __IO uint32_t ICR; /*!< I2C Interrupt clear register, Address offset: 0x1C */ + __IO uint32_t PECR; /*!< I2C PEC register, Address offset: 0x20 */ + __IO uint32_t RXDR; /*!< I2C Receive data register, Address offset: 0x24 */ + __IO uint32_t TXDR; /*!< I2C Transmit data register, Address offset: 0x28 */ +} I2C_TypeDef; + +/** + * @brief Independent WATCHDOG + */ + +typedef struct +{ + __IO uint32_t KR; /*!< IWDG Key register, Address offset: 0x00 */ + __IO uint32_t PR; /*!< IWDG Prescaler register, Address offset: 0x04 */ + __IO uint32_t RLR; /*!< IWDG Reload register, Address offset: 0x08 */ + __IO uint32_t SR; /*!< IWDG Status register, Address offset: 0x0C */ + __IO uint32_t WINR; /*!< IWDG Window register, Address offset: 0x10 */ +} IWDG_TypeDef; + +/** + * @brief LPTIMER + */ +typedef struct +{ + __IO uint32_t ISR; /*!< LPTIM Interrupt and Status register, Address offset: 0x00 */ + __IO uint32_t ICR; /*!< LPTIM Interrupt Clear register, Address offset: 0x04 */ + __IO uint32_t IER; /*!< LPTIM Interrupt Enable register, Address offset: 0x08 */ + __IO uint32_t CFGR; /*!< LPTIM Configuration register, Address offset: 0x0C */ + __IO uint32_t CR; /*!< LPTIM Control register, Address offset: 0x10 */ + __IO uint32_t CMP; /*!< LPTIM Compare register, Address offset: 0x14 */ + __IO uint32_t ARR; /*!< LPTIM Autoreload register, Address offset: 0x18 */ + __IO uint32_t CNT; /*!< LPTIM Counter register, Address offset: 0x1C */ + __IO uint32_t OR; /*!< LPTIM Option register, Address offset: 0x20 */ + __IO uint32_t RESERVED; /*!< Reserved, Address offset: 0x24 */ + __IO uint32_t RCR; /*!< LPTIM repetition counter register, Address offset: 0x28 */ +} LPTIM_TypeDef; + +/** + * @brief Operational Amplifier (OPAMP) + */ + +typedef struct +{ + __IO uint32_t CSR; /*!< OPAMP control/status register, Address offset: 0x00 */ + __IO uint32_t OTR; /*!< OPAMP offset trimming register for normal mode, Address offset: 0x04 */ + __IO uint32_t LPOTR; /*!< OPAMP offset trimming register for low power mode, Address offset: 0x08 */ +} OPAMP_TypeDef; + +typedef struct +{ + __IO uint32_t CSR; /*!< OPAMP control/status register, used for bits common to several OPAMP instances, Address offset: 0x00 */ +} OPAMP_Common_TypeDef; + +/** + * @brief Power Control + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< PWR power control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< PWR power control register 2, Address offset: 0x04 */ + __IO uint32_t CR3; /*!< PWR power control register 3, Address offset: 0x08 */ + __IO uint32_t CR4; /*!< PWR power control register 4, Address offset: 0x0C */ + __IO uint32_t SR1; /*!< PWR power status register 1, Address offset: 0x10 */ + __IO uint32_t SR2; /*!< PWR power status register 2, Address offset: 0x14 */ + __IO uint32_t SCR; /*!< PWR power status reset register, Address offset: 0x18 */ + uint32_t RESERVED; /*!< Reserved, Address offset: 0x1C */ + __IO uint32_t PUCRA; /*!< Pull_up control register of portA, Address offset: 0x20 */ + __IO uint32_t PDCRA; /*!< Pull_Down control register of portA, Address offset: 0x24 */ + __IO uint32_t PUCRB; /*!< Pull_up control register of portB, Address offset: 0x28 */ + __IO uint32_t PDCRB; /*!< Pull_Down control register of portB, Address offset: 0x2C */ + __IO uint32_t PUCRC; /*!< Pull_up control register of portC, Address offset: 0x30 */ + __IO uint32_t PDCRC; /*!< Pull_Down control register of portC, Address offset: 0x34 */ + __IO uint32_t PUCRD; /*!< Pull_up control register of portD, Address offset: 0x38 */ + __IO uint32_t PDCRD; /*!< Pull_Down control register of portD, Address offset: 0x3C */ + __IO uint32_t PUCRE; /*!< Pull_up control register of portE, Address offset: 0x40 */ + __IO uint32_t PDCRE; /*!< Pull_Down control register of portE, Address offset: 0x44 */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x48 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x4C */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x50 */ + uint32_t RESERVED4; /*!< Reserved, Address offset: 0x54 */ + __IO uint32_t PUCRH; /*!< Pull_up control register of portH, Address offset: 0x58 */ + __IO uint32_t PDCRH; /*!< Pull_Down control register of portH, Address offset: 0x5C */ +} PWR_TypeDef; + + +/** + * @brief QUAD Serial Peripheral Interface + */ + +typedef struct +{ + __IO uint32_t CR; /*!< QUADSPI Control register, Address offset: 0x00 */ + __IO uint32_t DCR; /*!< QUADSPI Device Configuration register, Address offset: 0x04 */ + __IO uint32_t SR; /*!< QUADSPI Status register, Address offset: 0x08 */ + __IO uint32_t FCR; /*!< QUADSPI Flag Clear register, Address offset: 0x0C */ + __IO uint32_t DLR; /*!< QUADSPI Data Length register, Address offset: 0x10 */ + __IO uint32_t CCR; /*!< QUADSPI Communication Configuration register, Address offset: 0x14 */ + __IO uint32_t AR; /*!< QUADSPI Address register, Address offset: 0x18 */ + __IO uint32_t ABR; /*!< QUADSPI Alternate Bytes register, Address offset: 0x1C */ + __IO uint32_t DR; /*!< QUADSPI Data register, Address offset: 0x20 */ + __IO uint32_t PSMKR; /*!< QUADSPI Polling Status Mask register, Address offset: 0x24 */ + __IO uint32_t PSMAR; /*!< QUADSPI Polling Status Match register, Address offset: 0x28 */ + __IO uint32_t PIR; /*!< QUADSPI Polling Interval register, Address offset: 0x2C */ + __IO uint32_t LPTR; /*!< QUADSPI Low Power Timeout register, Address offset: 0x30 */ +} QUADSPI_TypeDef; + + +/** + * @brief Reset and Clock Control + */ + +typedef struct +{ + __IO uint32_t CR; /*!< RCC clock control register, Address offset: 0x00 */ + __IO uint32_t ICSCR; /*!< RCC internal clock sources calibration register, Address offset: 0x04 */ + __IO uint32_t CFGR; /*!< RCC clock configuration register, Address offset: 0x08 */ + __IO uint32_t PLLCFGR; /*!< RCC system PLL configuration register, Address offset: 0x0C */ + uint32_t RESERVED8; /*!< Reserved, Address offset: 0x10 */ + uint32_t RESERVED; /*!< Reserved, Address offset: 0x14 */ + __IO uint32_t CIER; /*!< RCC clock interrupt enable register, Address offset: 0x18 */ + __IO uint32_t CIFR; /*!< RCC clock interrupt flag register, Address offset: 0x1C */ + __IO uint32_t CICR; /*!< RCC clock interrupt clear register, Address offset: 0x20 */ + uint32_t RESERVED0; /*!< Reserved, Address offset: 0x24 */ + __IO uint32_t AHB1RSTR; /*!< RCC AHB1 peripheral reset register, Address offset: 0x28 */ + __IO uint32_t AHB2RSTR; /*!< RCC AHB2 peripheral reset register, Address offset: 0x2C */ + __IO uint32_t AHB3RSTR; /*!< RCC AHB3 peripheral reset register, Address offset: 0x30 */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x34 */ + __IO uint32_t APB1RSTR1; /*!< RCC APB1 peripheral reset register 1, Address offset: 0x38 */ + __IO uint32_t APB1RSTR2; /*!< RCC APB1 peripheral reset register 2, Address offset: 0x3C */ + __IO uint32_t APB2RSTR; /*!< RCC APB2 peripheral reset register, Address offset: 0x40 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x44 */ + __IO uint32_t AHB1ENR; /*!< RCC AHB1 peripheral clocks enable register, Address offset: 0x48 */ + __IO uint32_t AHB2ENR; /*!< RCC AHB2 peripheral clocks enable register, Address offset: 0x4C */ + __IO uint32_t AHB3ENR; /*!< RCC AHB3 peripheral clocks enable register, Address offset: 0x50 */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x54 */ + __IO uint32_t APB1ENR1; /*!< RCC APB1 peripheral clocks enable register 1, Address offset: 0x58 */ + __IO uint32_t APB1ENR2; /*!< RCC APB1 peripheral clocks enable register 2, Address offset: 0x5C */ + __IO uint32_t APB2ENR; /*!< RCC APB2 peripheral clocks enable register, Address offset: 0x60 */ + uint32_t RESERVED4; /*!< Reserved, Address offset: 0x64 */ + __IO uint32_t AHB1SMENR; /*!< RCC AHB1 peripheral clocks enable in sleep and stop modes register, Address offset: 0x68 */ + __IO uint32_t AHB2SMENR; /*!< RCC AHB2 peripheral clocks enable in sleep and stop modes register, Address offset: 0x6C */ + __IO uint32_t AHB3SMENR; /*!< RCC AHB3 peripheral clocks enable in sleep and stop modes register, Address offset: 0x70 */ + uint32_t RESERVED5; /*!< Reserved, Address offset: 0x74 */ + __IO uint32_t APB1SMENR1; /*!< RCC APB1 peripheral clocks enable in sleep mode and stop modes register 1, Address offset: 0x78 */ + __IO uint32_t APB1SMENR2; /*!< RCC APB1 peripheral clocks enable in sleep mode and stop modes register 2, Address offset: 0x7C */ + __IO uint32_t APB2SMENR; /*!< RCC APB2 peripheral clocks enable in sleep mode and stop modes register, Address offset: 0x80 */ + uint32_t RESERVED6; /*!< Reserved, Address offset: 0x84 */ + __IO uint32_t CCIPR; /*!< RCC peripherals independent clock configuration register, Address offset: 0x88 */ + uint32_t RESERVED7; /*!< Reserved, Address offset: 0x8C */ + __IO uint32_t BDCR; /*!< RCC backup domain control register, Address offset: 0x90 */ + __IO uint32_t CSR; /*!< RCC clock control & status register, Address offset: 0x94 */ + __IO uint32_t CRRCR; /*!< RCC clock recovery RC register, Address offset: 0x98 */ +} RCC_TypeDef; + +/** + * @brief Real-Time Clock + */ + +typedef struct +{ + __IO uint32_t TR; /*!< RTC time register, Address offset: 0x00 */ + __IO uint32_t DR; /*!< RTC date register, Address offset: 0x04 */ + __IO uint32_t SSR; /*!< RTC sub second register, Address offset: 0x08 */ + __IO uint32_t ICSR; /*!< RTC initialization control and status register, Address offset: 0x0C */ + __IO uint32_t PRER; /*!< RTC prescaler register, Address offset: 0x10 */ + __IO uint32_t WUTR; /*!< RTC wakeup timer register, Address offset: 0x14 */ + __IO uint32_t CR; /*!< RTC control register, Address offset: 0x18 */ + uint32_t RESERVED0; /*!< Reserved, Address offset: 0x1C */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x20 */ + __IO uint32_t WPR; /*!< RTC write protection register, Address offset: 0x24 */ + __IO uint32_t CALR; /*!< RTC calibration register, Address offset: 0x28 */ + __IO uint32_t SHIFTR; /*!< RTC shift control register, Address offset: 0x2C */ + __IO uint32_t TSTR; /*!< RTC time stamp time register, Address offset: 0x30 */ + __IO uint32_t TSDR; /*!< RTC time stamp date register, Address offset: 0x34 */ + __IO uint32_t TSSSR; /*!< RTC time-stamp sub second register, Address offset: 0x38 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x3C */ + __IO uint32_t ALRMAR; /*!< RTC alarm A register, Address offset: 0x40 */ + __IO uint32_t ALRMASSR; /*!< RTC alarm A sub second register, Address offset: 0x44 */ + __IO uint32_t ALRMBR; /*!< RTC alarm B register, Address offset: 0x48 */ + __IO uint32_t ALRMBSSR; /*!< RTC alarm B sub second register, Address offset: 0x4C */ + __IO uint32_t SR; /*!< RTC Status register, Address offset: 0x50 */ + __IO uint32_t MISR; /*!< RTC masked interrupt status register, Address offset: 0x54 */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x58 */ + __IO uint32_t SCR; /*!< RTC status Clear register, Address offset: 0x5C */ +} RTC_TypeDef; + +/** + * @brief Tamper and backup registers + */ +typedef struct +{ + __IO uint32_t CR1; /*!< TAMP configuration register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< TAMP configuration register 2, Address offset: 0x04 */ + uint32_t RESERVED0; /*!< Reserved, Address offset: 0x08 */ + __IO uint32_t FLTCR; /*!< TAMP filter control register, Address offset: 0x0C */ + uint32_t RESERVED1[7];/*!< Reserved, Address offset: 0x10 -- 0x28 */ + __IO uint32_t IER; /*!< TAMP interrupt enable register, Address offset: 0x2C */ + __IO uint32_t SR; /*!< TAMP status register, Address offset: 0x30 */ + __IO uint32_t MISR; /*!< TAMP masked interrupt status register, Address offset: 0x34 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x38 */ + __IO uint32_t SCR; /*!< TAMP status clear register, Address offset: 0x3C */ + uint32_t RESERVED3[48];/*!< Reserved, Address offset: 0x40 -- 0xFC */ + __IO uint32_t BKP0R; /*!< TAMP backup register 0, Address offset: 0x100 */ + __IO uint32_t BKP1R; /*!< TAMP backup register 1, Address offset: 0x104 */ + __IO uint32_t BKP2R; /*!< TAMP backup register 2, Address offset: 0x108 */ + __IO uint32_t BKP3R; /*!< TAMP backup register 3, Address offset: 0x10C */ + __IO uint32_t BKP4R; /*!< TAMP backup register 4, Address offset: 0x110 */ + __IO uint32_t BKP5R; /*!< TAMP backup register 5, Address offset: 0x114 */ + __IO uint32_t BKP6R; /*!< TAMP backup register 6, Address offset: 0x118 */ + __IO uint32_t BKP7R; /*!< TAMP backup register 7, Address offset: 0x11C */ + __IO uint32_t BKP8R; /*!< TAMP backup register 8, Address offset: 0x120 */ + __IO uint32_t BKP9R; /*!< TAMP backup register 9, Address offset: 0x124 */ + __IO uint32_t BKP10R; /*!< TAMP backup register 10, Address offset: 0x128 */ + __IO uint32_t BKP11R; /*!< TAMP backup register 11, Address offset: 0x12C */ + __IO uint32_t BKP12R; /*!< TAMP backup register 12, Address offset: 0x130 */ + __IO uint32_t BKP13R; /*!< TAMP backup register 13, Address offset: 0x134 */ + __IO uint32_t BKP14R; /*!< TAMP backup register 14, Address offset: 0x138 */ + __IO uint32_t BKP15R; /*!< TAMP backup register 15, Address offset: 0x13C */ + __IO uint32_t BKP16R; /*!< TAMP backup register 16, Address offset: 0x140 */ + __IO uint32_t BKP17R; /*!< TAMP backup register 17, Address offset: 0x144 */ + __IO uint32_t BKP18R; /*!< TAMP backup register 18, Address offset: 0x148 */ + __IO uint32_t BKP19R; /*!< TAMP backup register 19, Address offset: 0x14C */ + __IO uint32_t BKP20R; /*!< TAMP backup register 20, Address offset: 0x150 */ + __IO uint32_t BKP21R; /*!< TAMP backup register 21, Address offset: 0x154 */ + __IO uint32_t BKP22R; /*!< TAMP backup register 22, Address offset: 0x158 */ + __IO uint32_t BKP23R; /*!< TAMP backup register 23, Address offset: 0x15C */ + __IO uint32_t BKP24R; /*!< TAMP backup register 24, Address offset: 0x160 */ + __IO uint32_t BKP25R; /*!< TAMP backup register 25, Address offset: 0x164 */ + __IO uint32_t BKP26R; /*!< TAMP backup register 26, Address offset: 0x168 */ + __IO uint32_t BKP27R; /*!< TAMP backup register 27, Address offset: 0x16C */ + __IO uint32_t BKP28R; /*!< TAMP backup register 28, Address offset: 0x170 */ + __IO uint32_t BKP29R; /*!< TAMP backup register 29, Address offset: 0x174 */ + __IO uint32_t BKP30R; /*!< TAMP backup register 30, Address offset: 0x178 */ + __IO uint32_t BKP31R; /*!< TAMP backup register 31, Address offset: 0x17C */ +} TAMP_TypeDef; + + + +/** + * @brief Serial Peripheral Interface + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< SPI Control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< SPI Control register 2, Address offset: 0x04 */ + __IO uint32_t SR; /*!< SPI Status register, Address offset: 0x08 */ + __IO uint32_t DR; /*!< SPI data register, Address offset: 0x0C */ + __IO uint32_t CRCPR; /*!< SPI CRC polynomial register, Address offset: 0x10 */ + __IO uint32_t RXCRCR; /*!< SPI Rx CRC register, Address offset: 0x14 */ + __IO uint32_t TXCRCR; /*!< SPI Tx CRC register, Address offset: 0x18 */ +} SPI_TypeDef; + + +/** + * @brief System configuration controller + */ + +typedef struct +{ + __IO uint32_t MEMRMP; /*!< SYSCFG memory remap register, Address offset: 0x00 */ + __IO uint32_t CFGR1; /*!< SYSCFG configuration register 1, Address offset: 0x04 */ + __IO uint32_t EXTICR[4]; /*!< SYSCFG external interrupt configuration registers, Address offset: 0x08-0x14 */ + __IO uint32_t SCSR; /*!< SYSCFG SRAM2 control and status register, Address offset: 0x18 */ + __IO uint32_t CFGR2; /*!< SYSCFG configuration register 2, Address offset: 0x1C */ + __IO uint32_t SWPR; /*!< SYSCFG SRAM2 write protection register, Address offset: 0x20 */ + __IO uint32_t SKR; /*!< SYSCFG SRAM2 key register, Address offset: 0x24 */ +} SYSCFG_TypeDef; + + +/** + * @brief TIM + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< TIM control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */ + __IO uint32_t SMCR; /*!< TIM slave mode control register, Address offset: 0x08 */ + __IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */ + __IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */ + __IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */ + __IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */ + __IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */ + __IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */ + __IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */ + __IO uint32_t PSC; /*!< TIM prescaler, Address offset: 0x28 */ + __IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */ + __IO uint32_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */ + __IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */ + __IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */ + __IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C */ + __IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */ + __IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */ + __IO uint32_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */ + __IO uint32_t DMAR; /*!< TIM DMA address for full transfer, Address offset: 0x4C */ + __IO uint32_t OR1; /*!< TIM option register 1, Address offset: 0x50 */ + __IO uint32_t CCMR3; /*!< TIM capture/compare mode register 3, Address offset: 0x54 */ + __IO uint32_t CCR5; /*!< TIM capture/compare register5, Address offset: 0x58 */ + __IO uint32_t CCR6; /*!< TIM capture/compare register6, Address offset: 0x5C */ + __IO uint32_t OR2; /*!< TIM option register 2, Address offset: 0x60 */ + __IO uint32_t OR3; /*!< TIM option register 3, Address offset: 0x64 */ +} TIM_TypeDef; + + +/** + * @brief Touch Sensing Controller (TSC) + */ + +typedef struct +{ + __IO uint32_t CR; /*!< TSC control register, Address offset: 0x00 */ + __IO uint32_t IER; /*!< TSC interrupt enable register, Address offset: 0x04 */ + __IO uint32_t ICR; /*!< TSC interrupt clear register, Address offset: 0x08 */ + __IO uint32_t ISR; /*!< TSC interrupt status register, Address offset: 0x0C */ + __IO uint32_t IOHCR; /*!< TSC I/O hysteresis control register, Address offset: 0x10 */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x14 */ + __IO uint32_t IOASCR; /*!< TSC I/O analog switch control register, Address offset: 0x18 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x1C */ + __IO uint32_t IOSCR; /*!< TSC I/O sampling control register, Address offset: 0x20 */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x24 */ + __IO uint32_t IOCCR; /*!< TSC I/O channel control register, Address offset: 0x28 */ + uint32_t RESERVED4; /*!< Reserved, Address offset: 0x2C */ + __IO uint32_t IOGCSR; /*!< TSC I/O group control status register, Address offset: 0x30 */ + __IO uint32_t IOGXCR[7]; /*!< TSC I/O group x counter register, Address offset: 0x34-4C */ +} TSC_TypeDef; + +/** + * @brief Universal Synchronous Asynchronous Receiver Transmitter + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< USART Control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< USART Control register 2, Address offset: 0x04 */ + __IO uint32_t CR3; /*!< USART Control register 3, Address offset: 0x08 */ + __IO uint32_t BRR; /*!< USART Baud rate register, Address offset: 0x0C */ + __IO uint16_t GTPR; /*!< USART Guard time and prescaler register, Address offset: 0x10 */ + uint16_t RESERVED2; /*!< Reserved, 0x12 */ + __IO uint32_t RTOR; /*!< USART Receiver Time Out register, Address offset: 0x14 */ + __IO uint16_t RQR; /*!< USART Request register, Address offset: 0x18 */ + uint16_t RESERVED3; /*!< Reserved, 0x1A */ + __IO uint32_t ISR; /*!< USART Interrupt and status register, Address offset: 0x1C */ + __IO uint32_t ICR; /*!< USART Interrupt flag Clear register, Address offset: 0x20 */ + __IO uint16_t RDR; /*!< USART Receive Data register, Address offset: 0x24 */ + uint16_t RESERVED4; /*!< Reserved, 0x26 */ + __IO uint16_t TDR; /*!< USART Transmit Data register, Address offset: 0x28 */ + uint16_t RESERVED5; /*!< Reserved, 0x2A */ +} USART_TypeDef; + +/** + * @brief Universal Serial Bus Full Speed Device + */ + +typedef struct +{ + __IO uint16_t EP0R; /*!< USB Endpoint 0 register, Address offset: 0x00 */ + __IO uint16_t RESERVED0; /*!< Reserved */ + __IO uint16_t EP1R; /*!< USB Endpoint 1 register, Address offset: 0x04 */ + __IO uint16_t RESERVED1; /*!< Reserved */ + __IO uint16_t EP2R; /*!< USB Endpoint 2 register, Address offset: 0x08 */ + __IO uint16_t RESERVED2; /*!< Reserved */ + __IO uint16_t EP3R; /*!< USB Endpoint 3 register, Address offset: 0x0C */ + __IO uint16_t RESERVED3; /*!< Reserved */ + __IO uint16_t EP4R; /*!< USB Endpoint 4 register, Address offset: 0x10 */ + __IO uint16_t RESERVED4; /*!< Reserved */ + __IO uint16_t EP5R; /*!< USB Endpoint 5 register, Address offset: 0x14 */ + __IO uint16_t RESERVED5; /*!< Reserved */ + __IO uint16_t EP6R; /*!< USB Endpoint 6 register, Address offset: 0x18 */ + __IO uint16_t RESERVED6; /*!< Reserved */ + __IO uint16_t EP7R; /*!< USB Endpoint 7 register, Address offset: 0x1C */ + __IO uint16_t RESERVED7[17]; /*!< Reserved */ + __IO uint16_t CNTR; /*!< Control register, Address offset: 0x40 */ + __IO uint16_t RESERVED8; /*!< Reserved */ + __IO uint16_t ISTR; /*!< Interrupt status register, Address offset: 0x44 */ + __IO uint16_t RESERVED9; /*!< Reserved */ + __IO uint16_t FNR; /*!< Frame number register, Address offset: 0x48 */ + __IO uint16_t RESERVEDA; /*!< Reserved */ + __IO uint16_t DADDR; /*!< Device address register, Address offset: 0x4C */ + __IO uint16_t RESERVEDB; /*!< Reserved */ + __IO uint16_t BTABLE; /*!< Buffer Table address register, Address offset: 0x50 */ + __IO uint16_t RESERVEDC; /*!< Reserved */ + __IO uint16_t LPMCSR; /*!< LPM Control and Status register, Address offset: 0x54 */ + __IO uint16_t RESERVEDD; /*!< Reserved */ + __IO uint16_t BCDR; /*!< Battery Charging detector register, Address offset: 0x58 */ + __IO uint16_t RESERVEDE; /*!< Reserved */ +} USB_TypeDef; + + +/** + * @brief Window WATCHDOG + */ + +typedef struct +{ + __IO uint32_t CR; /*!< WWDG Control register, Address offset: 0x00 */ + __IO uint32_t CFR; /*!< WWDG Configuration register, Address offset: 0x04 */ + __IO uint32_t SR; /*!< WWDG Status register, Address offset: 0x08 */ +} WWDG_TypeDef; + +/** + * @brief AES hardware accelerator + */ + +typedef struct +{ + __IO uint32_t CR; /*!< AES control register, Address offset: 0x00 */ + __IO uint32_t SR; /*!< AES status register, Address offset: 0x04 */ + __IO uint32_t DINR; /*!< AES data input register, Address offset: 0x08 */ + __IO uint32_t DOUTR; /*!< AES data output register, Address offset: 0x0C */ + __IO uint32_t KEYR0; /*!< AES key register 0, Address offset: 0x10 */ + __IO uint32_t KEYR1; /*!< AES key register 1, Address offset: 0x14 */ + __IO uint32_t KEYR2; /*!< AES key register 2, Address offset: 0x18 */ + __IO uint32_t KEYR3; /*!< AES key register 3, Address offset: 0x1C */ + __IO uint32_t IVR0; /*!< AES initialization vector register 0, Address offset: 0x20 */ + __IO uint32_t IVR1; /*!< AES initialization vector register 1, Address offset: 0x24 */ + __IO uint32_t IVR2; /*!< AES initialization vector register 2, Address offset: 0x28 */ + __IO uint32_t IVR3; /*!< AES initialization vector register 3, Address offset: 0x2C */ + __IO uint32_t KEYR4; /*!< AES key register 4, Address offset: 0x30 */ + __IO uint32_t KEYR5; /*!< AES key register 5, Address offset: 0x34 */ + __IO uint32_t KEYR6; /*!< AES key register 6, Address offset: 0x38 */ + __IO uint32_t KEYR7; /*!< AES key register 7, Address offset: 0x3C */ + __IO uint32_t SUSP0R; /*!< AES Suspend register 0, Address offset: 0x40 */ + __IO uint32_t SUSP1R; /*!< AES Suspend register 1, Address offset: 0x44 */ + __IO uint32_t SUSP2R; /*!< AES Suspend register 2, Address offset: 0x48 */ + __IO uint32_t SUSP3R; /*!< AES Suspend register 3, Address offset: 0x4C */ + __IO uint32_t SUSP4R; /*!< AES Suspend register 4, Address offset: 0x50 */ + __IO uint32_t SUSP5R; /*!< AES Suspend register 5, Address offset: 0x54 */ + __IO uint32_t SUSP6R; /*!< AES Suspend register 6, Address offset: 0x58 */ + __IO uint32_t SUSP7R; /*!< AES Suspend register 7, Address offset: 0x6C */ +} AES_TypeDef; + +/** + * @brief RNG + */ + +typedef struct +{ + __IO uint32_t CR; /*!< RNG control register, Address offset: 0x00 */ + __IO uint32_t SR; /*!< RNG status register, Address offset: 0x04 */ + __IO uint32_t DR; /*!< RNG data register, Address offset: 0x08 */ +} RNG_TypeDef; + +/** + * @} + */ + +/** @addtogroup Peripheral_memory_map + * @{ + */ +#define FLASH_BASE (0x08000000UL) /*!< FLASH(up to 128 KB) base address */ +#define FLASH_END (0x0801FFFFUL) /*!< FLASH END address */ +#define FLASH_BANK1_END (0x0801FFFFUL) /*!< FLASH END address of bank1 */ +#define SRAM1_BASE (0x20000000UL) /*!< SRAM1(up to 32 KB) base address */ +#define SRAM2_BASE (0x10000000UL) /*!< SRAM2(8 KB) base address */ +#define PERIPH_BASE (0x40000000UL) /*!< Peripheral base address */ +#define QSPI_BASE (0x90000000UL) /*!< QUADSPI memories accessible over AHB base address */ + +#define QSPI_R_BASE (0xA0001000UL) /*!< QUADSPI control registers base address */ +#define SRAM1_BB_BASE (0x22000000UL) /*!< SRAM1(96 KB) base address in the bit-band region */ +#define PERIPH_BB_BASE (0x42000000UL) /*!< Peripheral base address in the bit-band region */ + +/* Legacy defines */ +#define SRAM_BASE SRAM1_BASE +#define SRAM_BB_BASE SRAM1_BB_BASE + +#define SRAM1_SIZE_MAX (0x00008000UL) /*!< maximum SRAM1 size (up to 32 KBytes) */ +#define SRAM2_SIZE (0x00002000UL) /*!< SRAM2 size (8 KBytes) */ + +#define FLASH_SIZE_DATA_REGISTER (0x1FFF75E0UL) + +#define FLASH_SIZE (((((*((uint32_t *)FLASH_SIZE_DATA_REGISTER)) & (0x0000FFFFU)) == 0x0000FFFFU)) ? (0x80U << 10U) : \ + (((*((uint32_t *)FLASH_SIZE_DATA_REGISTER)) & (0x0000FFFFU)) << 10U)) + +/*!< Peripheral memory map */ +#define APB1PERIPH_BASE PERIPH_BASE +#define APB2PERIPH_BASE (PERIPH_BASE + 0x00010000UL) +#define AHB1PERIPH_BASE (PERIPH_BASE + 0x00020000UL) +#define AHB2PERIPH_BASE (PERIPH_BASE + 0x08000000UL) + + +/*!< APB1 peripherals */ +#define TIM2_BASE (APB1PERIPH_BASE + 0x0000UL) +#define TIM6_BASE (APB1PERIPH_BASE + 0x1000UL) +#define RTC_BASE (APB1PERIPH_BASE + 0x2800UL) +#define WWDG_BASE (APB1PERIPH_BASE + 0x2C00UL) +#define IWDG_BASE (APB1PERIPH_BASE + 0x3000UL) +#define TAMP_BASE (APB1PERIPH_BASE + 0x3400U) +#define SPI2_BASE (APB1PERIPH_BASE + 0x3800UL) +#define USART2_BASE (APB1PERIPH_BASE + 0x4400UL) +#define USART3_BASE (APB1PERIPH_BASE + 0x4800UL) +#define I2C1_BASE (APB1PERIPH_BASE + 0x5400UL) +#define I2C2_BASE (APB1PERIPH_BASE + 0x5800UL) +#define I2C3_BASE (APB1PERIPH_BASE + 0x5C00UL) +#define CRS_BASE (APB1PERIPH_BASE + 0x6000UL) +#define USB_BASE (APB1PERIPH_BASE + 0x6800UL) /*!< USB_IP Peripheral Registers base address */ +#define USB_PMAADDR (APB1PERIPH_BASE + 0x6C00UL) /*!< USB_IP Packet Memory Area base address */ +#define PWR_BASE (APB1PERIPH_BASE + 0x7000UL) +#define OPAMP_BASE (APB1PERIPH_BASE + 0x7800UL) +#define OPAMP1_BASE (APB1PERIPH_BASE + 0x7800UL) +#define LPTIM1_BASE (APB1PERIPH_BASE + 0x7C00UL) +#define LPUART1_BASE (APB1PERIPH_BASE + 0x8000UL) +#define LPTIM2_BASE (APB1PERIPH_BASE + 0x9400UL) + + +/*!< APB2 peripherals */ +#define SYSCFG_BASE (APB2PERIPH_BASE + 0x0000UL) +#define COMP1_BASE (APB2PERIPH_BASE + 0x0200UL) +#define EXTI_BASE (APB2PERIPH_BASE + 0x0400UL) +#define FIREWALL_BASE (APB2PERIPH_BASE + 0x1C00UL) +#define TIM1_BASE (APB2PERIPH_BASE + 0x2C00UL) +#define SPI1_BASE (APB2PERIPH_BASE + 0x3000UL) +#define USART1_BASE (APB2PERIPH_BASE + 0x3800UL) +#define TIM15_BASE (APB2PERIPH_BASE + 0x4000UL) +#define TIM16_BASE (APB2PERIPH_BASE + 0x4400UL) + +/*!< AHB1 peripherals */ +#define DMA1_BASE (AHB1PERIPH_BASE) +#define DMA2_BASE (AHB1PERIPH_BASE + 0x0400UL) +#define RCC_BASE (AHB1PERIPH_BASE + 0x1000UL) +#define FLASH_R_BASE (AHB1PERIPH_BASE + 0x2000UL) +#define CRC_BASE (AHB1PERIPH_BASE + 0x3000UL) +#define TSC_BASE (AHB1PERIPH_BASE + 0x4000UL) + + +#define DMA1_Channel1_BASE (DMA1_BASE + 0x0008UL) +#define DMA1_Channel2_BASE (DMA1_BASE + 0x001CUL) +#define DMA1_Channel3_BASE (DMA1_BASE + 0x0030UL) +#define DMA1_Channel4_BASE (DMA1_BASE + 0x0044UL) +#define DMA1_Channel5_BASE (DMA1_BASE + 0x0058UL) +#define DMA1_Channel6_BASE (DMA1_BASE + 0x006CUL) +#define DMA1_Channel7_BASE (DMA1_BASE + 0x0080UL) +#define DMA1_CSELR_BASE (DMA1_BASE + 0x00A8UL) + + +#define DMA2_Channel1_BASE (DMA2_BASE + 0x0008UL) +#define DMA2_Channel2_BASE (DMA2_BASE + 0x001CUL) +#define DMA2_Channel3_BASE (DMA2_BASE + 0x0030UL) +#define DMA2_Channel4_BASE (DMA2_BASE + 0x0044UL) +#define DMA2_Channel5_BASE (DMA2_BASE + 0x0058UL) +#define DMA2_Channel6_BASE (DMA2_BASE + 0x006CUL) +#define DMA2_Channel7_BASE (DMA2_BASE + 0x0080UL) +#define DMA2_CSELR_BASE (DMA2_BASE + 0x00A8UL) + + +/*!< AHB2 peripherals */ +#define GPIOA_BASE (AHB2PERIPH_BASE + 0x0000UL) +#define GPIOB_BASE (AHB2PERIPH_BASE + 0x0400UL) +#define GPIOC_BASE (AHB2PERIPH_BASE + 0x0800UL) +#define GPIOD_BASE (AHB2PERIPH_BASE + 0x0C00UL) +#define GPIOH_BASE (AHB2PERIPH_BASE + 0x1C00UL) + + +#define ADC1_BASE (AHB2PERIPH_BASE + 0x08040000UL) +#define ADC2_BASE (AHB2PERIPH_BASE + 0x08040100UL) +#define ADC12_COMMON_BASE (AHB2PERIPH_BASE + 0x08040300UL) + + +#define AES_BASE (AHB2PERIPH_BASE + 0x08060000UL) +#define RNG_BASE (AHB2PERIPH_BASE + 0x08060800UL) + + + +/* Debug MCU registers base address */ +#define DBGMCU_BASE (0xE0042000UL) + + +#define PACKAGE_BASE (0x1FFF7500UL) /*!< Package data register base address */ +#define UID_BASE (0x1FFF7590UL) /*!< Unique device ID register base address */ +#define FLASHSIZE_BASE (0x1FFF75E0UL) /*!< Flash size data register base address */ +/** + * @} + */ + +/** @addtogroup Peripheral_declaration + * @{ + */ +#define TIM2 ((TIM_TypeDef *) TIM2_BASE) +#define TIM6 ((TIM_TypeDef *) TIM6_BASE) +#define RTC ((RTC_TypeDef *) RTC_BASE) +#define WWDG ((WWDG_TypeDef *) WWDG_BASE) +#define IWDG ((IWDG_TypeDef *) IWDG_BASE) +#define TAMP ((TAMP_TypeDef *) TAMP_BASE) +#define SPI2 ((SPI_TypeDef *) SPI2_BASE) +#define USART2 ((USART_TypeDef *) USART2_BASE) +#define USART3 ((USART_TypeDef *) USART3_BASE) +#define I2C1 ((I2C_TypeDef *) I2C1_BASE) +#define I2C2 ((I2C_TypeDef *) I2C2_BASE) +#define I2C3 ((I2C_TypeDef *) I2C3_BASE) +#define CRS ((CRS_TypeDef *) CRS_BASE) +#define USB ((USB_TypeDef *) USB_BASE) +#define PWR ((PWR_TypeDef *) PWR_BASE) +#define OPAMP ((OPAMP_TypeDef *) OPAMP_BASE) +#define OPAMP1 ((OPAMP_TypeDef *) OPAMP1_BASE) +#define OPAMP1_COMMON ((OPAMP_Common_TypeDef *) OPAMP1_BASE) +#define LPTIM1 ((LPTIM_TypeDef *) LPTIM1_BASE) +#define LPUART1 ((USART_TypeDef *) LPUART1_BASE) +#define LPTIM2 ((LPTIM_TypeDef *) LPTIM2_BASE) + +#define SYSCFG ((SYSCFG_TypeDef *) SYSCFG_BASE) +#define COMP1 ((COMP_TypeDef *) COMP1_BASE) +#define EXTI ((EXTI_TypeDef *) EXTI_BASE) +#define FIREWALL ((FIREWALL_TypeDef *) FIREWALL_BASE) +#define TIM1 ((TIM_TypeDef *) TIM1_BASE) +#define SPI1 ((SPI_TypeDef *) SPI1_BASE) +#define USART1 ((USART_TypeDef *) USART1_BASE) +#define TIM15 ((TIM_TypeDef *) TIM15_BASE) +#define TIM16 ((TIM_TypeDef *) TIM16_BASE) +#define DMA1 ((DMA_TypeDef *) DMA1_BASE) +#define DMA2 ((DMA_TypeDef *) DMA2_BASE) +#define RCC ((RCC_TypeDef *) RCC_BASE) +#define FLASH ((FLASH_TypeDef *) FLASH_R_BASE) +#define CRC ((CRC_TypeDef *) CRC_BASE) +#define TSC ((TSC_TypeDef *) TSC_BASE) + +#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE) +#define GPIOB ((GPIO_TypeDef *) GPIOB_BASE) +#define GPIOC ((GPIO_TypeDef *) GPIOC_BASE) +#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE) +#define GPIOH ((GPIO_TypeDef *) GPIOH_BASE) +#define ADC1 ((ADC_TypeDef *) ADC1_BASE) +#define ADC2 ((ADC_TypeDef *) ADC2_BASE) +#define ADC12_COMMON ((ADC_Common_TypeDef *) ADC12_COMMON_BASE) +#define AES ((AES_TypeDef *) AES_BASE) +#define RNG ((RNG_TypeDef *) RNG_BASE) + + +#define DMA1_Channel1 ((DMA_Channel_TypeDef *) DMA1_Channel1_BASE) +#define DMA1_Channel2 ((DMA_Channel_TypeDef *) DMA1_Channel2_BASE) +#define DMA1_Channel3 ((DMA_Channel_TypeDef *) DMA1_Channel3_BASE) +#define DMA1_Channel4 ((DMA_Channel_TypeDef *) DMA1_Channel4_BASE) +#define DMA1_Channel5 ((DMA_Channel_TypeDef *) DMA1_Channel5_BASE) +#define DMA1_Channel6 ((DMA_Channel_TypeDef *) DMA1_Channel6_BASE) +#define DMA1_Channel7 ((DMA_Channel_TypeDef *) DMA1_Channel7_BASE) +#define DMA1_CSELR ((DMA_Request_TypeDef *) DMA1_CSELR_BASE) + + +#define DMA2_Channel1 ((DMA_Channel_TypeDef *) DMA2_Channel1_BASE) +#define DMA2_Channel2 ((DMA_Channel_TypeDef *) DMA2_Channel2_BASE) +#define DMA2_Channel3 ((DMA_Channel_TypeDef *) DMA2_Channel3_BASE) +#define DMA2_Channel4 ((DMA_Channel_TypeDef *) DMA2_Channel4_BASE) +#define DMA2_Channel5 ((DMA_Channel_TypeDef *) DMA2_Channel5_BASE) +#define DMA2_Channel6 ((DMA_Channel_TypeDef *) DMA2_Channel6_BASE) +#define DMA2_Channel7 ((DMA_Channel_TypeDef *) DMA2_Channel7_BASE) +#define DMA2_CSELR ((DMA_Request_TypeDef *) DMA2_CSELR_BASE) + + + +#define QUADSPI ((QUADSPI_TypeDef *) QSPI_R_BASE) + +#define DBGMCU ((DBGMCU_TypeDef *) DBGMCU_BASE) + +/** + * @} + */ + +/** @addtogroup Exported_constants + * @{ + */ + +/** @addtogroup Hardware_Constant_Definition + * @{ + */ +#define LSI_STARTUP_TIME 130U /*!< LSI Maximum startup time in us */ + +/** + * @} + */ + +/** @addtogroup Peripheral_Registers_Bits_Definition + * @{ + */ + +/******************************************************************************/ +/* Peripheral Registers_Bits_Definition */ +/******************************************************************************/ + +/******************************************************************************/ +/* */ +/* Analog to Digital Converter */ +/* */ +/******************************************************************************/ + +/* + * @brief Specific device feature definitions (not present on all devices in the STM32L4 series) + */ +#define ADC_MULTIMODE_SUPPORT /*!< ADC feature available only on specific devices: multimode available on devices with several ADC instances */ + +/******************** Bit definition for ADC_ISR register *******************/ +#define ADC_ISR_ADRDY_Pos (0U) +#define ADC_ISR_ADRDY_Msk (0x1UL << ADC_ISR_ADRDY_Pos) /*!< 0x00000001 */ +#define ADC_ISR_ADRDY ADC_ISR_ADRDY_Msk /*!< ADC ready flag */ +#define ADC_ISR_EOSMP_Pos (1U) +#define ADC_ISR_EOSMP_Msk (0x1UL << ADC_ISR_EOSMP_Pos) /*!< 0x00000002 */ +#define ADC_ISR_EOSMP ADC_ISR_EOSMP_Msk /*!< ADC group regular end of sampling flag */ +#define ADC_ISR_EOC_Pos (2U) +#define ADC_ISR_EOC_Msk (0x1UL << ADC_ISR_EOC_Pos) /*!< 0x00000004 */ +#define ADC_ISR_EOC ADC_ISR_EOC_Msk /*!< ADC group regular end of unitary conversion flag */ +#define ADC_ISR_EOS_Pos (3U) +#define ADC_ISR_EOS_Msk (0x1UL << ADC_ISR_EOS_Pos) /*!< 0x00000008 */ +#define ADC_ISR_EOS ADC_ISR_EOS_Msk /*!< ADC group regular end of sequence conversions flag */ +#define ADC_ISR_OVR_Pos (4U) +#define ADC_ISR_OVR_Msk (0x1UL << ADC_ISR_OVR_Pos) /*!< 0x00000010 */ +#define ADC_ISR_OVR ADC_ISR_OVR_Msk /*!< ADC group regular overrun flag */ +#define ADC_ISR_JEOC_Pos (5U) +#define ADC_ISR_JEOC_Msk (0x1UL << ADC_ISR_JEOC_Pos) /*!< 0x00000020 */ +#define ADC_ISR_JEOC ADC_ISR_JEOC_Msk /*!< ADC group injected end of unitary conversion flag */ +#define ADC_ISR_JEOS_Pos (6U) +#define ADC_ISR_JEOS_Msk (0x1UL << ADC_ISR_JEOS_Pos) /*!< 0x00000040 */ +#define ADC_ISR_JEOS ADC_ISR_JEOS_Msk /*!< ADC group injected end of sequence conversions flag */ +#define ADC_ISR_AWD1_Pos (7U) +#define ADC_ISR_AWD1_Msk (0x1UL << ADC_ISR_AWD1_Pos) /*!< 0x00000080 */ +#define ADC_ISR_AWD1 ADC_ISR_AWD1_Msk /*!< ADC analog watchdog 1 flag */ +#define ADC_ISR_AWD2_Pos (8U) +#define ADC_ISR_AWD2_Msk (0x1UL << ADC_ISR_AWD2_Pos) /*!< 0x00000100 */ +#define ADC_ISR_AWD2 ADC_ISR_AWD2_Msk /*!< ADC analog watchdog 2 flag */ +#define ADC_ISR_AWD3_Pos (9U) +#define ADC_ISR_AWD3_Msk (0x1UL << ADC_ISR_AWD3_Pos) /*!< 0x00000200 */ +#define ADC_ISR_AWD3 ADC_ISR_AWD3_Msk /*!< ADC analog watchdog 3 flag */ +#define ADC_ISR_JQOVF_Pos (10U) +#define ADC_ISR_JQOVF_Msk (0x1UL << ADC_ISR_JQOVF_Pos) /*!< 0x00000400 */ +#define ADC_ISR_JQOVF ADC_ISR_JQOVF_Msk /*!< ADC group injected contexts queue overflow flag */ + +/******************** Bit definition for ADC_IER register *******************/ +#define ADC_IER_ADRDYIE_Pos (0U) +#define ADC_IER_ADRDYIE_Msk (0x1UL << ADC_IER_ADRDYIE_Pos) /*!< 0x00000001 */ +#define ADC_IER_ADRDYIE ADC_IER_ADRDYIE_Msk /*!< ADC ready interrupt */ +#define ADC_IER_EOSMPIE_Pos (1U) +#define ADC_IER_EOSMPIE_Msk (0x1UL << ADC_IER_EOSMPIE_Pos) /*!< 0x00000002 */ +#define ADC_IER_EOSMPIE ADC_IER_EOSMPIE_Msk /*!< ADC group regular end of sampling interrupt */ +#define ADC_IER_EOCIE_Pos (2U) +#define ADC_IER_EOCIE_Msk (0x1UL << ADC_IER_EOCIE_Pos) /*!< 0x00000004 */ +#define ADC_IER_EOCIE ADC_IER_EOCIE_Msk /*!< ADC group regular end of unitary conversion interrupt */ +#define ADC_IER_EOSIE_Pos (3U) +#define ADC_IER_EOSIE_Msk (0x1UL << ADC_IER_EOSIE_Pos) /*!< 0x00000008 */ +#define ADC_IER_EOSIE ADC_IER_EOSIE_Msk /*!< ADC group regular end of sequence conversions interrupt */ +#define ADC_IER_OVRIE_Pos (4U) +#define ADC_IER_OVRIE_Msk (0x1UL << ADC_IER_OVRIE_Pos) /*!< 0x00000010 */ +#define ADC_IER_OVRIE ADC_IER_OVRIE_Msk /*!< ADC group regular overrun interrupt */ +#define ADC_IER_JEOCIE_Pos (5U) +#define ADC_IER_JEOCIE_Msk (0x1UL << ADC_IER_JEOCIE_Pos) /*!< 0x00000020 */ +#define ADC_IER_JEOCIE ADC_IER_JEOCIE_Msk /*!< ADC group injected end of unitary conversion interrupt */ +#define ADC_IER_JEOSIE_Pos (6U) +#define ADC_IER_JEOSIE_Msk (0x1UL << ADC_IER_JEOSIE_Pos) /*!< 0x00000040 */ +#define ADC_IER_JEOSIE ADC_IER_JEOSIE_Msk /*!< ADC group injected end of sequence conversions interrupt */ +#define ADC_IER_AWD1IE_Pos (7U) +#define ADC_IER_AWD1IE_Msk (0x1UL << ADC_IER_AWD1IE_Pos) /*!< 0x00000080 */ +#define ADC_IER_AWD1IE ADC_IER_AWD1IE_Msk /*!< ADC analog watchdog 1 interrupt */ +#define ADC_IER_AWD2IE_Pos (8U) +#define ADC_IER_AWD2IE_Msk (0x1UL << ADC_IER_AWD2IE_Pos) /*!< 0x00000100 */ +#define ADC_IER_AWD2IE ADC_IER_AWD2IE_Msk /*!< ADC analog watchdog 2 interrupt */ +#define ADC_IER_AWD3IE_Pos (9U) +#define ADC_IER_AWD3IE_Msk (0x1UL << ADC_IER_AWD3IE_Pos) /*!< 0x00000200 */ +#define ADC_IER_AWD3IE ADC_IER_AWD3IE_Msk /*!< ADC analog watchdog 3 interrupt */ +#define ADC_IER_JQOVFIE_Pos (10U) +#define ADC_IER_JQOVFIE_Msk (0x1UL << ADC_IER_JQOVFIE_Pos) /*!< 0x00000400 */ +#define ADC_IER_JQOVFIE ADC_IER_JQOVFIE_Msk /*!< ADC group injected contexts queue overflow interrupt */ + +/* Legacy defines */ +#define ADC_IER_ADRDY (ADC_IER_ADRDYIE) +#define ADC_IER_EOSMP (ADC_IER_EOSMPIE) +#define ADC_IER_EOC (ADC_IER_EOCIE) +#define ADC_IER_EOS (ADC_IER_EOSIE) +#define ADC_IER_OVR (ADC_IER_OVRIE) +#define ADC_IER_JEOC (ADC_IER_JEOCIE) +#define ADC_IER_JEOS (ADC_IER_JEOSIE) +#define ADC_IER_AWD1 (ADC_IER_AWD1IE) +#define ADC_IER_AWD2 (ADC_IER_AWD2IE) +#define ADC_IER_AWD3 (ADC_IER_AWD3IE) +#define ADC_IER_JQOVF (ADC_IER_JQOVFIE) + +/******************** Bit definition for ADC_CR register ********************/ +#define ADC_CR_ADEN_Pos (0U) +#define ADC_CR_ADEN_Msk (0x1UL << ADC_CR_ADEN_Pos) /*!< 0x00000001 */ +#define ADC_CR_ADEN ADC_CR_ADEN_Msk /*!< ADC enable */ +#define ADC_CR_ADDIS_Pos (1U) +#define ADC_CR_ADDIS_Msk (0x1UL << ADC_CR_ADDIS_Pos) /*!< 0x00000002 */ +#define ADC_CR_ADDIS ADC_CR_ADDIS_Msk /*!< ADC disable */ +#define ADC_CR_ADSTART_Pos (2U) +#define ADC_CR_ADSTART_Msk (0x1UL << ADC_CR_ADSTART_Pos) /*!< 0x00000004 */ +#define ADC_CR_ADSTART ADC_CR_ADSTART_Msk /*!< ADC group regular conversion start */ +#define ADC_CR_JADSTART_Pos (3U) +#define ADC_CR_JADSTART_Msk (0x1UL << ADC_CR_JADSTART_Pos) /*!< 0x00000008 */ +#define ADC_CR_JADSTART ADC_CR_JADSTART_Msk /*!< ADC group injected conversion start */ +#define ADC_CR_ADSTP_Pos (4U) +#define ADC_CR_ADSTP_Msk (0x1UL << ADC_CR_ADSTP_Pos) /*!< 0x00000010 */ +#define ADC_CR_ADSTP ADC_CR_ADSTP_Msk /*!< ADC group regular conversion stop */ +#define ADC_CR_JADSTP_Pos (5U) +#define ADC_CR_JADSTP_Msk (0x1UL << ADC_CR_JADSTP_Pos) /*!< 0x00000020 */ +#define ADC_CR_JADSTP ADC_CR_JADSTP_Msk /*!< ADC group injected conversion stop */ +#define ADC_CR_ADVREGEN_Pos (28U) +#define ADC_CR_ADVREGEN_Msk (0x1UL << ADC_CR_ADVREGEN_Pos) /*!< 0x10000000 */ +#define ADC_CR_ADVREGEN ADC_CR_ADVREGEN_Msk /*!< ADC voltage regulator enable */ +#define ADC_CR_DEEPPWD_Pos (29U) +#define ADC_CR_DEEPPWD_Msk (0x1UL << ADC_CR_DEEPPWD_Pos) /*!< 0x20000000 */ +#define ADC_CR_DEEPPWD ADC_CR_DEEPPWD_Msk /*!< ADC deep power down enable */ +#define ADC_CR_ADCALDIF_Pos (30U) +#define ADC_CR_ADCALDIF_Msk (0x1UL << ADC_CR_ADCALDIF_Pos) /*!< 0x40000000 */ +#define ADC_CR_ADCALDIF ADC_CR_ADCALDIF_Msk /*!< ADC differential mode for calibration */ +#define ADC_CR_ADCAL_Pos (31U) +#define ADC_CR_ADCAL_Msk (0x1UL << ADC_CR_ADCAL_Pos) /*!< 0x80000000 */ +#define ADC_CR_ADCAL ADC_CR_ADCAL_Msk /*!< ADC calibration */ + +/******************** Bit definition for ADC_CFGR register ******************/ +#define ADC_CFGR_DMAEN_Pos (0U) +#define ADC_CFGR_DMAEN_Msk (0x1UL << ADC_CFGR_DMAEN_Pos) /*!< 0x00000001 */ +#define ADC_CFGR_DMAEN ADC_CFGR_DMAEN_Msk /*!< ADC DMA transfer enable */ +#define ADC_CFGR_DMACFG_Pos (1U) +#define ADC_CFGR_DMACFG_Msk (0x1UL << ADC_CFGR_DMACFG_Pos) /*!< 0x00000002 */ +#define ADC_CFGR_DMACFG ADC_CFGR_DMACFG_Msk /*!< ADC DMA transfer configuration */ + +#define ADC_CFGR_RES_Pos (3U) +#define ADC_CFGR_RES_Msk (0x3UL << ADC_CFGR_RES_Pos) /*!< 0x00000018 */ +#define ADC_CFGR_RES ADC_CFGR_RES_Msk /*!< ADC data resolution */ +#define ADC_CFGR_RES_0 (0x1UL << ADC_CFGR_RES_Pos) /*!< 0x00000008 */ +#define ADC_CFGR_RES_1 (0x2UL << ADC_CFGR_RES_Pos) /*!< 0x00000010 */ + +#define ADC_CFGR_ALIGN_Pos (5U) +#define ADC_CFGR_ALIGN_Msk (0x1UL << ADC_CFGR_ALIGN_Pos) /*!< 0x00000020 */ +#define ADC_CFGR_ALIGN ADC_CFGR_ALIGN_Msk /*!< ADC data alignment */ + +#define ADC_CFGR_EXTSEL_Pos (6U) +#define ADC_CFGR_EXTSEL_Msk (0xFUL << ADC_CFGR_EXTSEL_Pos) /*!< 0x000003C0 */ +#define ADC_CFGR_EXTSEL ADC_CFGR_EXTSEL_Msk /*!< ADC group regular external trigger source */ +#define ADC_CFGR_EXTSEL_0 (0x1UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000040 */ +#define ADC_CFGR_EXTSEL_1 (0x2UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000080 */ +#define ADC_CFGR_EXTSEL_2 (0x4UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000100 */ +#define ADC_CFGR_EXTSEL_3 (0x8UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000200 */ + +#define ADC_CFGR_EXTEN_Pos (10U) +#define ADC_CFGR_EXTEN_Msk (0x3UL << ADC_CFGR_EXTEN_Pos) /*!< 0x00000C00 */ +#define ADC_CFGR_EXTEN ADC_CFGR_EXTEN_Msk /*!< ADC group regular external trigger polarity */ +#define ADC_CFGR_EXTEN_0 (0x1UL << ADC_CFGR_EXTEN_Pos) /*!< 0x00000400 */ +#define ADC_CFGR_EXTEN_1 (0x2UL << ADC_CFGR_EXTEN_Pos) /*!< 0x00000800 */ + +#define ADC_CFGR_OVRMOD_Pos (12U) +#define ADC_CFGR_OVRMOD_Msk (0x1UL << ADC_CFGR_OVRMOD_Pos) /*!< 0x00001000 */ +#define ADC_CFGR_OVRMOD ADC_CFGR_OVRMOD_Msk /*!< ADC group regular overrun configuration */ +#define ADC_CFGR_CONT_Pos (13U) +#define ADC_CFGR_CONT_Msk (0x1UL << ADC_CFGR_CONT_Pos) /*!< 0x00002000 */ +#define ADC_CFGR_CONT ADC_CFGR_CONT_Msk /*!< ADC group regular continuous conversion mode */ +#define ADC_CFGR_AUTDLY_Pos (14U) +#define ADC_CFGR_AUTDLY_Msk (0x1UL << ADC_CFGR_AUTDLY_Pos) /*!< 0x00004000 */ +#define ADC_CFGR_AUTDLY ADC_CFGR_AUTDLY_Msk /*!< ADC low power auto wait */ + +#define ADC_CFGR_DISCEN_Pos (16U) +#define ADC_CFGR_DISCEN_Msk (0x1UL << ADC_CFGR_DISCEN_Pos) /*!< 0x00010000 */ +#define ADC_CFGR_DISCEN ADC_CFGR_DISCEN_Msk /*!< ADC group regular sequencer discontinuous mode */ + +#define ADC_CFGR_DISCNUM_Pos (17U) +#define ADC_CFGR_DISCNUM_Msk (0x7UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x000E0000 */ +#define ADC_CFGR_DISCNUM ADC_CFGR_DISCNUM_Msk /*!< ADC group regular sequencer discontinuous number of ranks */ +#define ADC_CFGR_DISCNUM_0 (0x1UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x00020000 */ +#define ADC_CFGR_DISCNUM_1 (0x2UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x00040000 */ +#define ADC_CFGR_DISCNUM_2 (0x4UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x00080000 */ + +#define ADC_CFGR_JDISCEN_Pos (20U) +#define ADC_CFGR_JDISCEN_Msk (0x1UL << ADC_CFGR_JDISCEN_Pos) /*!< 0x00100000 */ +#define ADC_CFGR_JDISCEN ADC_CFGR_JDISCEN_Msk /*!< ADC group injected sequencer discontinuous mode */ +#define ADC_CFGR_JQM_Pos (21U) +#define ADC_CFGR_JQM_Msk (0x1UL << ADC_CFGR_JQM_Pos) /*!< 0x00200000 */ +#define ADC_CFGR_JQM ADC_CFGR_JQM_Msk /*!< ADC group injected contexts queue mode */ +#define ADC_CFGR_AWD1SGL_Pos (22U) +#define ADC_CFGR_AWD1SGL_Msk (0x1UL << ADC_CFGR_AWD1SGL_Pos) /*!< 0x00400000 */ +#define ADC_CFGR_AWD1SGL ADC_CFGR_AWD1SGL_Msk /*!< ADC analog watchdog 1 monitoring a single channel or all channels */ +#define ADC_CFGR_AWD1EN_Pos (23U) +#define ADC_CFGR_AWD1EN_Msk (0x1UL << ADC_CFGR_AWD1EN_Pos) /*!< 0x00800000 */ +#define ADC_CFGR_AWD1EN ADC_CFGR_AWD1EN_Msk /*!< ADC analog watchdog 1 enable on scope ADC group regular */ +#define ADC_CFGR_JAWD1EN_Pos (24U) +#define ADC_CFGR_JAWD1EN_Msk (0x1UL << ADC_CFGR_JAWD1EN_Pos) /*!< 0x01000000 */ +#define ADC_CFGR_JAWD1EN ADC_CFGR_JAWD1EN_Msk /*!< ADC analog watchdog 1 enable on scope ADC group injected */ +#define ADC_CFGR_JAUTO_Pos (25U) +#define ADC_CFGR_JAUTO_Msk (0x1UL << ADC_CFGR_JAUTO_Pos) /*!< 0x02000000 */ +#define ADC_CFGR_JAUTO ADC_CFGR_JAUTO_Msk /*!< ADC group injected automatic trigger mode */ + +#define ADC_CFGR_AWD1CH_Pos (26U) +#define ADC_CFGR_AWD1CH_Msk (0x1FUL << ADC_CFGR_AWD1CH_Pos) /*!< 0x7C000000 */ +#define ADC_CFGR_AWD1CH ADC_CFGR_AWD1CH_Msk /*!< ADC analog watchdog 1 monitored channel selection */ +#define ADC_CFGR_AWD1CH_0 (0x01UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x04000000 */ +#define ADC_CFGR_AWD1CH_1 (0x02UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x08000000 */ +#define ADC_CFGR_AWD1CH_2 (0x04UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x10000000 */ +#define ADC_CFGR_AWD1CH_3 (0x08UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x20000000 */ +#define ADC_CFGR_AWD1CH_4 (0x10UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x40000000 */ + +#define ADC_CFGR_JQDIS_Pos (31U) +#define ADC_CFGR_JQDIS_Msk (0x1UL << ADC_CFGR_JQDIS_Pos) /*!< 0x80000000 */ +#define ADC_CFGR_JQDIS ADC_CFGR_JQDIS_Msk /*!< ADC group injected contexts queue disable */ + +/******************** Bit definition for ADC_CFGR2 register *****************/ +#define ADC_CFGR2_ROVSE_Pos (0U) +#define ADC_CFGR2_ROVSE_Msk (0x1UL << ADC_CFGR2_ROVSE_Pos) /*!< 0x00000001 */ +#define ADC_CFGR2_ROVSE ADC_CFGR2_ROVSE_Msk /*!< ADC oversampler enable on scope ADC group regular */ +#define ADC_CFGR2_JOVSE_Pos (1U) +#define ADC_CFGR2_JOVSE_Msk (0x1UL << ADC_CFGR2_JOVSE_Pos) /*!< 0x00000002 */ +#define ADC_CFGR2_JOVSE ADC_CFGR2_JOVSE_Msk /*!< ADC oversampler enable on scope ADC group injected */ + +#define ADC_CFGR2_OVSR_Pos (2U) +#define ADC_CFGR2_OVSR_Msk (0x7UL << ADC_CFGR2_OVSR_Pos) /*!< 0x0000001C */ +#define ADC_CFGR2_OVSR ADC_CFGR2_OVSR_Msk /*!< ADC oversampling ratio */ +#define ADC_CFGR2_OVSR_0 (0x1UL << ADC_CFGR2_OVSR_Pos) /*!< 0x00000004 */ +#define ADC_CFGR2_OVSR_1 (0x2UL << ADC_CFGR2_OVSR_Pos) /*!< 0x00000008 */ +#define ADC_CFGR2_OVSR_2 (0x4UL << ADC_CFGR2_OVSR_Pos) /*!< 0x00000010 */ + +#define ADC_CFGR2_OVSS_Pos (5U) +#define ADC_CFGR2_OVSS_Msk (0xFUL << ADC_CFGR2_OVSS_Pos) /*!< 0x000001E0 */ +#define ADC_CFGR2_OVSS ADC_CFGR2_OVSS_Msk /*!< ADC oversampling shift */ +#define ADC_CFGR2_OVSS_0 (0x1UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000020 */ +#define ADC_CFGR2_OVSS_1 (0x2UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000040 */ +#define ADC_CFGR2_OVSS_2 (0x4UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000080 */ +#define ADC_CFGR2_OVSS_3 (0x8UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000100 */ + +#define ADC_CFGR2_TROVS_Pos (9U) +#define ADC_CFGR2_TROVS_Msk (0x1UL << ADC_CFGR2_TROVS_Pos) /*!< 0x00000200 */ +#define ADC_CFGR2_TROVS ADC_CFGR2_TROVS_Msk /*!< ADC oversampling discontinuous mode (triggered mode) for ADC group regular */ +#define ADC_CFGR2_ROVSM_Pos (10U) +#define ADC_CFGR2_ROVSM_Msk (0x1UL << ADC_CFGR2_ROVSM_Pos) /*!< 0x00000400 */ +#define ADC_CFGR2_ROVSM ADC_CFGR2_ROVSM_Msk /*!< ADC oversampling mode managing interlaced conversions of ADC group regular and group injected */ + +/******************** Bit definition for ADC_SMPR1 register *****************/ +#define ADC_SMPR1_SMP0_Pos (0U) +#define ADC_SMPR1_SMP0_Msk (0x7UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000007 */ +#define ADC_SMPR1_SMP0 ADC_SMPR1_SMP0_Msk /*!< ADC channel 0 sampling time selection */ +#define ADC_SMPR1_SMP0_0 (0x1UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000001 */ +#define ADC_SMPR1_SMP0_1 (0x2UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000002 */ +#define ADC_SMPR1_SMP0_2 (0x4UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000004 */ + +#define ADC_SMPR1_SMP1_Pos (3U) +#define ADC_SMPR1_SMP1_Msk (0x7UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000038 */ +#define ADC_SMPR1_SMP1 ADC_SMPR1_SMP1_Msk /*!< ADC channel 1 sampling time selection */ +#define ADC_SMPR1_SMP1_0 (0x1UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000008 */ +#define ADC_SMPR1_SMP1_1 (0x2UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000010 */ +#define ADC_SMPR1_SMP1_2 (0x4UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000020 */ + +#define ADC_SMPR1_SMP2_Pos (6U) +#define ADC_SMPR1_SMP2_Msk (0x7UL << ADC_SMPR1_SMP2_Pos) /*!< 0x000001C0 */ +#define ADC_SMPR1_SMP2 ADC_SMPR1_SMP2_Msk /*!< ADC channel 2 sampling time selection */ +#define ADC_SMPR1_SMP2_0 (0x1UL << ADC_SMPR1_SMP2_Pos) /*!< 0x00000040 */ +#define ADC_SMPR1_SMP2_1 (0x2UL << ADC_SMPR1_SMP2_Pos) /*!< 0x00000080 */ +#define ADC_SMPR1_SMP2_2 (0x4UL << ADC_SMPR1_SMP2_Pos) /*!< 0x00000100 */ + +#define ADC_SMPR1_SMP3_Pos (9U) +#define ADC_SMPR1_SMP3_Msk (0x7UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000E00 */ +#define ADC_SMPR1_SMP3 ADC_SMPR1_SMP3_Msk /*!< ADC channel 3 sampling time selection */ +#define ADC_SMPR1_SMP3_0 (0x1UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000200 */ +#define ADC_SMPR1_SMP3_1 (0x2UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000400 */ +#define ADC_SMPR1_SMP3_2 (0x4UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000800 */ + +#define ADC_SMPR1_SMP4_Pos (12U) +#define ADC_SMPR1_SMP4_Msk (0x7UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00007000 */ +#define ADC_SMPR1_SMP4 ADC_SMPR1_SMP4_Msk /*!< ADC channel 4 sampling time selection */ +#define ADC_SMPR1_SMP4_0 (0x1UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00001000 */ +#define ADC_SMPR1_SMP4_1 (0x2UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00002000 */ +#define ADC_SMPR1_SMP4_2 (0x4UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00004000 */ + +#define ADC_SMPR1_SMP5_Pos (15U) +#define ADC_SMPR1_SMP5_Msk (0x7UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00038000 */ +#define ADC_SMPR1_SMP5 ADC_SMPR1_SMP5_Msk /*!< ADC channel 5 sampling time selection */ +#define ADC_SMPR1_SMP5_0 (0x1UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00008000 */ +#define ADC_SMPR1_SMP5_1 (0x2UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00010000 */ +#define ADC_SMPR1_SMP5_2 (0x4UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00020000 */ + +#define ADC_SMPR1_SMP6_Pos (18U) +#define ADC_SMPR1_SMP6_Msk (0x7UL << ADC_SMPR1_SMP6_Pos) /*!< 0x001C0000 */ +#define ADC_SMPR1_SMP6 ADC_SMPR1_SMP6_Msk /*!< ADC channel 6 sampling time selection */ +#define ADC_SMPR1_SMP6_0 (0x1UL << ADC_SMPR1_SMP6_Pos) /*!< 0x00040000 */ +#define ADC_SMPR1_SMP6_1 (0x2UL << ADC_SMPR1_SMP6_Pos) /*!< 0x00080000 */ +#define ADC_SMPR1_SMP6_2 (0x4UL << ADC_SMPR1_SMP6_Pos) /*!< 0x00100000 */ + +#define ADC_SMPR1_SMP7_Pos (21U) +#define ADC_SMPR1_SMP7_Msk (0x7UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00E00000 */ +#define ADC_SMPR1_SMP7 ADC_SMPR1_SMP7_Msk /*!< ADC channel 7 sampling time selection */ +#define ADC_SMPR1_SMP7_0 (0x1UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00200000 */ +#define ADC_SMPR1_SMP7_1 (0x2UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00400000 */ +#define ADC_SMPR1_SMP7_2 (0x4UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00800000 */ + +#define ADC_SMPR1_SMP8_Pos (24U) +#define ADC_SMPR1_SMP8_Msk (0x7UL << ADC_SMPR1_SMP8_Pos) /*!< 0x07000000 */ +#define ADC_SMPR1_SMP8 ADC_SMPR1_SMP8_Msk /*!< ADC channel 8 sampling time selection */ +#define ADC_SMPR1_SMP8_0 (0x1UL << ADC_SMPR1_SMP8_Pos) /*!< 0x01000000 */ +#define ADC_SMPR1_SMP8_1 (0x2UL << ADC_SMPR1_SMP8_Pos) /*!< 0x02000000 */ +#define ADC_SMPR1_SMP8_2 (0x4UL << ADC_SMPR1_SMP8_Pos) /*!< 0x04000000 */ + +#define ADC_SMPR1_SMP9_Pos (27U) +#define ADC_SMPR1_SMP9_Msk (0x7UL << ADC_SMPR1_SMP9_Pos) /*!< 0x38000000 */ +#define ADC_SMPR1_SMP9 ADC_SMPR1_SMP9_Msk /*!< ADC channel 9 sampling time selection */ +#define ADC_SMPR1_SMP9_0 (0x1UL << ADC_SMPR1_SMP9_Pos) /*!< 0x08000000 */ +#define ADC_SMPR1_SMP9_1 (0x2UL << ADC_SMPR1_SMP9_Pos) /*!< 0x10000000 */ +#define ADC_SMPR1_SMP9_2 (0x4UL << ADC_SMPR1_SMP9_Pos) /*!< 0x20000000 */ + +#define ADC_SMPR1_SMPPLUS_Pos (31U) +#define ADC_SMPR1_SMPPLUS_Msk (0x1UL << ADC_SMPR1_SMPPLUS_Pos) /*!< 0x80000000 */ +#define ADC_SMPR1_SMPPLUS ADC_SMPR1_SMPPLUS_Msk /*!< ADC channels sampling time additional setting */ + +/******************** Bit definition for ADC_SMPR2 register *****************/ +#define ADC_SMPR2_SMP10_Pos (0U) +#define ADC_SMPR2_SMP10_Msk (0x7UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000007 */ +#define ADC_SMPR2_SMP10 ADC_SMPR2_SMP10_Msk /*!< ADC channel 10 sampling time selection */ +#define ADC_SMPR2_SMP10_0 (0x1UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000001 */ +#define ADC_SMPR2_SMP10_1 (0x2UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000002 */ +#define ADC_SMPR2_SMP10_2 (0x4UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000004 */ + +#define ADC_SMPR2_SMP11_Pos (3U) +#define ADC_SMPR2_SMP11_Msk (0x7UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000038 */ +#define ADC_SMPR2_SMP11 ADC_SMPR2_SMP11_Msk /*!< ADC channel 11 sampling time selection */ +#define ADC_SMPR2_SMP11_0 (0x1UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000008 */ +#define ADC_SMPR2_SMP11_1 (0x2UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000010 */ +#define ADC_SMPR2_SMP11_2 (0x4UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000020 */ + +#define ADC_SMPR2_SMP12_Pos (6U) +#define ADC_SMPR2_SMP12_Msk (0x7UL << ADC_SMPR2_SMP12_Pos) /*!< 0x000001C0 */ +#define ADC_SMPR2_SMP12 ADC_SMPR2_SMP12_Msk /*!< ADC channel 12 sampling time selection */ +#define ADC_SMPR2_SMP12_0 (0x1UL << ADC_SMPR2_SMP12_Pos) /*!< 0x00000040 */ +#define ADC_SMPR2_SMP12_1 (0x2UL << ADC_SMPR2_SMP12_Pos) /*!< 0x00000080 */ +#define ADC_SMPR2_SMP12_2 (0x4UL << ADC_SMPR2_SMP12_Pos) /*!< 0x00000100 */ + +#define ADC_SMPR2_SMP13_Pos (9U) +#define ADC_SMPR2_SMP13_Msk (0x7UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000E00 */ +#define ADC_SMPR2_SMP13 ADC_SMPR2_SMP13_Msk /*!< ADC channel 13 sampling time selection */ +#define ADC_SMPR2_SMP13_0 (0x1UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000200 */ +#define ADC_SMPR2_SMP13_1 (0x2UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000400 */ +#define ADC_SMPR2_SMP13_2 (0x4UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000800 */ + +#define ADC_SMPR2_SMP14_Pos (12U) +#define ADC_SMPR2_SMP14_Msk (0x7UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00007000 */ +#define ADC_SMPR2_SMP14 ADC_SMPR2_SMP14_Msk /*!< ADC channel 14 sampling time selection */ +#define ADC_SMPR2_SMP14_0 (0x1UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00001000 */ +#define ADC_SMPR2_SMP14_1 (0x2UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00002000 */ +#define ADC_SMPR2_SMP14_2 (0x4UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00004000 */ + +#define ADC_SMPR2_SMP15_Pos (15U) +#define ADC_SMPR2_SMP15_Msk (0x7UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00038000 */ +#define ADC_SMPR2_SMP15 ADC_SMPR2_SMP15_Msk /*!< ADC channel 15 sampling time selection */ +#define ADC_SMPR2_SMP15_0 (0x1UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00008000 */ +#define ADC_SMPR2_SMP15_1 (0x2UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00010000 */ +#define ADC_SMPR2_SMP15_2 (0x4UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00020000 */ + +#define ADC_SMPR2_SMP16_Pos (18U) +#define ADC_SMPR2_SMP16_Msk (0x7UL << ADC_SMPR2_SMP16_Pos) /*!< 0x001C0000 */ +#define ADC_SMPR2_SMP16 ADC_SMPR2_SMP16_Msk /*!< ADC channel 16 sampling time selection */ +#define ADC_SMPR2_SMP16_0 (0x1UL << ADC_SMPR2_SMP16_Pos) /*!< 0x00040000 */ +#define ADC_SMPR2_SMP16_1 (0x2UL << ADC_SMPR2_SMP16_Pos) /*!< 0x00080000 */ +#define ADC_SMPR2_SMP16_2 (0x4UL << ADC_SMPR2_SMP16_Pos) /*!< 0x00100000 */ + +#define ADC_SMPR2_SMP17_Pos (21U) +#define ADC_SMPR2_SMP17_Msk (0x7UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00E00000 */ +#define ADC_SMPR2_SMP17 ADC_SMPR2_SMP17_Msk /*!< ADC channel 17 sampling time selection */ +#define ADC_SMPR2_SMP17_0 (0x1UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00200000 */ +#define ADC_SMPR2_SMP17_1 (0x2UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00400000 */ +#define ADC_SMPR2_SMP17_2 (0x4UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00800000 */ + +#define ADC_SMPR2_SMP18_Pos (24U) +#define ADC_SMPR2_SMP18_Msk (0x7UL << ADC_SMPR2_SMP18_Pos) /*!< 0x07000000 */ +#define ADC_SMPR2_SMP18 ADC_SMPR2_SMP18_Msk /*!< ADC channel 18 sampling time selection */ +#define ADC_SMPR2_SMP18_0 (0x1UL << ADC_SMPR2_SMP18_Pos) /*!< 0x01000000 */ +#define ADC_SMPR2_SMP18_1 (0x2UL << ADC_SMPR2_SMP18_Pos) /*!< 0x02000000 */ +#define ADC_SMPR2_SMP18_2 (0x4UL << ADC_SMPR2_SMP18_Pos) /*!< 0x04000000 */ + +/******************** Bit definition for ADC_TR1 register *******************/ +#define ADC_TR1_LT1_Pos (0U) +#define ADC_TR1_LT1_Msk (0xFFFUL << ADC_TR1_LT1_Pos) /*!< 0x00000FFF */ +#define ADC_TR1_LT1 ADC_TR1_LT1_Msk /*!< ADC analog watchdog 1 threshold low */ +#define ADC_TR1_LT1_0 (0x001UL << ADC_TR1_LT1_Pos) /*!< 0x00000001 */ +#define ADC_TR1_LT1_1 (0x002UL << ADC_TR1_LT1_Pos) /*!< 0x00000002 */ +#define ADC_TR1_LT1_2 (0x004UL << ADC_TR1_LT1_Pos) /*!< 0x00000004 */ +#define ADC_TR1_LT1_3 (0x008UL << ADC_TR1_LT1_Pos) /*!< 0x00000008 */ +#define ADC_TR1_LT1_4 (0x010UL << ADC_TR1_LT1_Pos) /*!< 0x00000010 */ +#define ADC_TR1_LT1_5 (0x020UL << ADC_TR1_LT1_Pos) /*!< 0x00000020 */ +#define ADC_TR1_LT1_6 (0x040UL << ADC_TR1_LT1_Pos) /*!< 0x00000040 */ +#define ADC_TR1_LT1_7 (0x080UL << ADC_TR1_LT1_Pos) /*!< 0x00000080 */ +#define ADC_TR1_LT1_8 (0x100UL << ADC_TR1_LT1_Pos) /*!< 0x00000100 */ +#define ADC_TR1_LT1_9 (0x200UL << ADC_TR1_LT1_Pos) /*!< 0x00000200 */ +#define ADC_TR1_LT1_10 (0x400UL << ADC_TR1_LT1_Pos) /*!< 0x00000400 */ +#define ADC_TR1_LT1_11 (0x800UL << ADC_TR1_LT1_Pos) /*!< 0x00000800 */ + +#define ADC_TR1_HT1_Pos (16U) +#define ADC_TR1_HT1_Msk (0xFFFUL << ADC_TR1_HT1_Pos) /*!< 0x0FFF0000 */ +#define ADC_TR1_HT1 ADC_TR1_HT1_Msk /*!< ADC Analog watchdog 1 threshold high */ +#define ADC_TR1_HT1_0 (0x001UL << ADC_TR1_HT1_Pos) /*!< 0x00010000 */ +#define ADC_TR1_HT1_1 (0x002UL << ADC_TR1_HT1_Pos) /*!< 0x00020000 */ +#define ADC_TR1_HT1_2 (0x004UL << ADC_TR1_HT1_Pos) /*!< 0x00040000 */ +#define ADC_TR1_HT1_3 (0x008UL << ADC_TR1_HT1_Pos) /*!< 0x00080000 */ +#define ADC_TR1_HT1_4 (0x010UL << ADC_TR1_HT1_Pos) /*!< 0x00100000 */ +#define ADC_TR1_HT1_5 (0x020UL << ADC_TR1_HT1_Pos) /*!< 0x00200000 */ +#define ADC_TR1_HT1_6 (0x040UL << ADC_TR1_HT1_Pos) /*!< 0x00400000 */ +#define ADC_TR1_HT1_7 (0x080UL << ADC_TR1_HT1_Pos) /*!< 0x00800000 */ +#define ADC_TR1_HT1_8 (0x100UL << ADC_TR1_HT1_Pos) /*!< 0x01000000 */ +#define ADC_TR1_HT1_9 (0x200UL << ADC_TR1_HT1_Pos) /*!< 0x02000000 */ +#define ADC_TR1_HT1_10 (0x400UL << ADC_TR1_HT1_Pos) /*!< 0x04000000 */ +#define ADC_TR1_HT1_11 (0x800UL << ADC_TR1_HT1_Pos) /*!< 0x08000000 */ + +/******************** Bit definition for ADC_TR2 register *******************/ +#define ADC_TR2_LT2_Pos (0U) +#define ADC_TR2_LT2_Msk (0xFFUL << ADC_TR2_LT2_Pos) /*!< 0x000000FF */ +#define ADC_TR2_LT2 ADC_TR2_LT2_Msk /*!< ADC analog watchdog 2 threshold low */ +#define ADC_TR2_LT2_0 (0x01UL << ADC_TR2_LT2_Pos) /*!< 0x00000001 */ +#define ADC_TR2_LT2_1 (0x02UL << ADC_TR2_LT2_Pos) /*!< 0x00000002 */ +#define ADC_TR2_LT2_2 (0x04UL << ADC_TR2_LT2_Pos) /*!< 0x00000004 */ +#define ADC_TR2_LT2_3 (0x08UL << ADC_TR2_LT2_Pos) /*!< 0x00000008 */ +#define ADC_TR2_LT2_4 (0x10UL << ADC_TR2_LT2_Pos) /*!< 0x00000010 */ +#define ADC_TR2_LT2_5 (0x20UL << ADC_TR2_LT2_Pos) /*!< 0x00000020 */ +#define ADC_TR2_LT2_6 (0x40UL << ADC_TR2_LT2_Pos) /*!< 0x00000040 */ +#define ADC_TR2_LT2_7 (0x80UL << ADC_TR2_LT2_Pos) /*!< 0x00000080 */ + +#define ADC_TR2_HT2_Pos (16U) +#define ADC_TR2_HT2_Msk (0xFFUL << ADC_TR2_HT2_Pos) /*!< 0x00FF0000 */ +#define ADC_TR2_HT2 ADC_TR2_HT2_Msk /*!< ADC analog watchdog 2 threshold high */ +#define ADC_TR2_HT2_0 (0x01UL << ADC_TR2_HT2_Pos) /*!< 0x00010000 */ +#define ADC_TR2_HT2_1 (0x02UL << ADC_TR2_HT2_Pos) /*!< 0x00020000 */ +#define ADC_TR2_HT2_2 (0x04UL << ADC_TR2_HT2_Pos) /*!< 0x00040000 */ +#define ADC_TR2_HT2_3 (0x08UL << ADC_TR2_HT2_Pos) /*!< 0x00080000 */ +#define ADC_TR2_HT2_4 (0x10UL << ADC_TR2_HT2_Pos) /*!< 0x00100000 */ +#define ADC_TR2_HT2_5 (0x20UL << ADC_TR2_HT2_Pos) /*!< 0x00200000 */ +#define ADC_TR2_HT2_6 (0x40UL << ADC_TR2_HT2_Pos) /*!< 0x00400000 */ +#define ADC_TR2_HT2_7 (0x80UL << ADC_TR2_HT2_Pos) /*!< 0x00800000 */ + +/******************** Bit definition for ADC_TR3 register *******************/ +#define ADC_TR3_LT3_Pos (0U) +#define ADC_TR3_LT3_Msk (0xFFUL << ADC_TR3_LT3_Pos) /*!< 0x000000FF */ +#define ADC_TR3_LT3 ADC_TR3_LT3_Msk /*!< ADC analog watchdog 3 threshold low */ +#define ADC_TR3_LT3_0 (0x01UL << ADC_TR3_LT3_Pos) /*!< 0x00000001 */ +#define ADC_TR3_LT3_1 (0x02UL << ADC_TR3_LT3_Pos) /*!< 0x00000002 */ +#define ADC_TR3_LT3_2 (0x04UL << ADC_TR3_LT3_Pos) /*!< 0x00000004 */ +#define ADC_TR3_LT3_3 (0x08UL << ADC_TR3_LT3_Pos) /*!< 0x00000008 */ +#define ADC_TR3_LT3_4 (0x10UL << ADC_TR3_LT3_Pos) /*!< 0x00000010 */ +#define ADC_TR3_LT3_5 (0x20UL << ADC_TR3_LT3_Pos) /*!< 0x00000020 */ +#define ADC_TR3_LT3_6 (0x40UL << ADC_TR3_LT3_Pos) /*!< 0x00000040 */ +#define ADC_TR3_LT3_7 (0x80UL << ADC_TR3_LT3_Pos) /*!< 0x00000080 */ + +#define ADC_TR3_HT3_Pos (16U) +#define ADC_TR3_HT3_Msk (0xFFUL << ADC_TR3_HT3_Pos) /*!< 0x00FF0000 */ +#define ADC_TR3_HT3 ADC_TR3_HT3_Msk /*!< ADC analog watchdog 3 threshold high */ +#define ADC_TR3_HT3_0 (0x01UL << ADC_TR3_HT3_Pos) /*!< 0x00010000 */ +#define ADC_TR3_HT3_1 (0x02UL << ADC_TR3_HT3_Pos) /*!< 0x00020000 */ +#define ADC_TR3_HT3_2 (0x04UL << ADC_TR3_HT3_Pos) /*!< 0x00040000 */ +#define ADC_TR3_HT3_3 (0x08UL << ADC_TR3_HT3_Pos) /*!< 0x00080000 */ +#define ADC_TR3_HT3_4 (0x10UL << ADC_TR3_HT3_Pos) /*!< 0x00100000 */ +#define ADC_TR3_HT3_5 (0x20UL << ADC_TR3_HT3_Pos) /*!< 0x00200000 */ +#define ADC_TR3_HT3_6 (0x40UL << ADC_TR3_HT3_Pos) /*!< 0x00400000 */ +#define ADC_TR3_HT3_7 (0x80UL << ADC_TR3_HT3_Pos) /*!< 0x00800000 */ + +/******************** Bit definition for ADC_SQR1 register ******************/ +#define ADC_SQR1_L_Pos (0U) +#define ADC_SQR1_L_Msk (0xFUL << ADC_SQR1_L_Pos) /*!< 0x0000000F */ +#define ADC_SQR1_L ADC_SQR1_L_Msk /*!< ADC group regular sequencer scan length */ +#define ADC_SQR1_L_0 (0x1UL << ADC_SQR1_L_Pos) /*!< 0x00000001 */ +#define ADC_SQR1_L_1 (0x2UL << ADC_SQR1_L_Pos) /*!< 0x00000002 */ +#define ADC_SQR1_L_2 (0x4UL << ADC_SQR1_L_Pos) /*!< 0x00000004 */ +#define ADC_SQR1_L_3 (0x8UL << ADC_SQR1_L_Pos) /*!< 0x00000008 */ + +#define ADC_SQR1_SQ1_Pos (6U) +#define ADC_SQR1_SQ1_Msk (0x1FUL << ADC_SQR1_SQ1_Pos) /*!< 0x000007C0 */ +#define ADC_SQR1_SQ1 ADC_SQR1_SQ1_Msk /*!< ADC group regular sequencer rank 1 */ +#define ADC_SQR1_SQ1_0 (0x01UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000040 */ +#define ADC_SQR1_SQ1_1 (0x02UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000080 */ +#define ADC_SQR1_SQ1_2 (0x04UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000100 */ +#define ADC_SQR1_SQ1_3 (0x08UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000200 */ +#define ADC_SQR1_SQ1_4 (0x10UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000400 */ + +#define ADC_SQR1_SQ2_Pos (12U) +#define ADC_SQR1_SQ2_Msk (0x1FUL << ADC_SQR1_SQ2_Pos) /*!< 0x0001F000 */ +#define ADC_SQR1_SQ2 ADC_SQR1_SQ2_Msk /*!< ADC group regular sequencer rank 2 */ +#define ADC_SQR1_SQ2_0 (0x01UL << ADC_SQR1_SQ2_Pos) /*!< 0x00001000 */ +#define ADC_SQR1_SQ2_1 (0x02UL << ADC_SQR1_SQ2_Pos) /*!< 0x00002000 */ +#define ADC_SQR1_SQ2_2 (0x04UL << ADC_SQR1_SQ2_Pos) /*!< 0x00004000 */ +#define ADC_SQR1_SQ2_3 (0x08UL << ADC_SQR1_SQ2_Pos) /*!< 0x00008000 */ +#define ADC_SQR1_SQ2_4 (0x10UL << ADC_SQR1_SQ2_Pos) /*!< 0x00010000 */ + +#define ADC_SQR1_SQ3_Pos (18U) +#define ADC_SQR1_SQ3_Msk (0x1FUL << ADC_SQR1_SQ3_Pos) /*!< 0x007C0000 */ +#define ADC_SQR1_SQ3 ADC_SQR1_SQ3_Msk /*!< ADC group regular sequencer rank 3 */ +#define ADC_SQR1_SQ3_0 (0x01UL << ADC_SQR1_SQ3_Pos) /*!< 0x00040000 */ +#define ADC_SQR1_SQ3_1 (0x02UL << ADC_SQR1_SQ3_Pos) /*!< 0x00080000 */ +#define ADC_SQR1_SQ3_2 (0x04UL << ADC_SQR1_SQ3_Pos) /*!< 0x00100000 */ +#define ADC_SQR1_SQ3_3 (0x08UL << ADC_SQR1_SQ3_Pos) /*!< 0x00200000 */ +#define ADC_SQR1_SQ3_4 (0x10UL << ADC_SQR1_SQ3_Pos) /*!< 0x00400000 */ + +#define ADC_SQR1_SQ4_Pos (24U) +#define ADC_SQR1_SQ4_Msk (0x1FUL << ADC_SQR1_SQ4_Pos) /*!< 0x1F000000 */ +#define ADC_SQR1_SQ4 ADC_SQR1_SQ4_Msk /*!< ADC group regular sequencer rank 4 */ +#define ADC_SQR1_SQ4_0 (0x01UL << ADC_SQR1_SQ4_Pos) /*!< 0x01000000 */ +#define ADC_SQR1_SQ4_1 (0x02UL << ADC_SQR1_SQ4_Pos) /*!< 0x02000000 */ +#define ADC_SQR1_SQ4_2 (0x04UL << ADC_SQR1_SQ4_Pos) /*!< 0x04000000 */ +#define ADC_SQR1_SQ4_3 (0x08UL << ADC_SQR1_SQ4_Pos) /*!< 0x08000000 */ +#define ADC_SQR1_SQ4_4 (0x10UL << ADC_SQR1_SQ4_Pos) /*!< 0x10000000 */ + +/******************** Bit definition for ADC_SQR2 register ******************/ +#define ADC_SQR2_SQ5_Pos (0U) +#define ADC_SQR2_SQ5_Msk (0x1FUL << ADC_SQR2_SQ5_Pos) /*!< 0x0000001F */ +#define ADC_SQR2_SQ5 ADC_SQR2_SQ5_Msk /*!< ADC group regular sequencer rank 5 */ +#define ADC_SQR2_SQ5_0 (0x01UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000001 */ +#define ADC_SQR2_SQ5_1 (0x02UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000002 */ +#define ADC_SQR2_SQ5_2 (0x04UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000004 */ +#define ADC_SQR2_SQ5_3 (0x08UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000008 */ +#define ADC_SQR2_SQ5_4 (0x10UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000010 */ + +#define ADC_SQR2_SQ6_Pos (6U) +#define ADC_SQR2_SQ6_Msk (0x1FUL << ADC_SQR2_SQ6_Pos) /*!< 0x000007C0 */ +#define ADC_SQR2_SQ6 ADC_SQR2_SQ6_Msk /*!< ADC group regular sequencer rank 6 */ +#define ADC_SQR2_SQ6_0 (0x01UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000040 */ +#define ADC_SQR2_SQ6_1 (0x02UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000080 */ +#define ADC_SQR2_SQ6_2 (0x04UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000100 */ +#define ADC_SQR2_SQ6_3 (0x08UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000200 */ +#define ADC_SQR2_SQ6_4 (0x10UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000400 */ + +#define ADC_SQR2_SQ7_Pos (12U) +#define ADC_SQR2_SQ7_Msk (0x1FUL << ADC_SQR2_SQ7_Pos) /*!< 0x0001F000 */ +#define ADC_SQR2_SQ7 ADC_SQR2_SQ7_Msk /*!< ADC group regular sequencer rank 7 */ +#define ADC_SQR2_SQ7_0 (0x01UL << ADC_SQR2_SQ7_Pos) /*!< 0x00001000 */ +#define ADC_SQR2_SQ7_1 (0x02UL << ADC_SQR2_SQ7_Pos) /*!< 0x00002000 */ +#define ADC_SQR2_SQ7_2 (0x04UL << ADC_SQR2_SQ7_Pos) /*!< 0x00004000 */ +#define ADC_SQR2_SQ7_3 (0x08UL << ADC_SQR2_SQ7_Pos) /*!< 0x00008000 */ +#define ADC_SQR2_SQ7_4 (0x10UL << ADC_SQR2_SQ7_Pos) /*!< 0x00010000 */ + +#define ADC_SQR2_SQ8_Pos (18U) +#define ADC_SQR2_SQ8_Msk (0x1FUL << ADC_SQR2_SQ8_Pos) /*!< 0x007C0000 */ +#define ADC_SQR2_SQ8 ADC_SQR2_SQ8_Msk /*!< ADC group regular sequencer rank 8 */ +#define ADC_SQR2_SQ8_0 (0x01UL << ADC_SQR2_SQ8_Pos) /*!< 0x00040000 */ +#define ADC_SQR2_SQ8_1 (0x02UL << ADC_SQR2_SQ8_Pos) /*!< 0x00080000 */ +#define ADC_SQR2_SQ8_2 (0x04UL << ADC_SQR2_SQ8_Pos) /*!< 0x00100000 */ +#define ADC_SQR2_SQ8_3 (0x08UL << ADC_SQR2_SQ8_Pos) /*!< 0x00200000 */ +#define ADC_SQR2_SQ8_4 (0x10UL << ADC_SQR2_SQ8_Pos) /*!< 0x00400000 */ + +#define ADC_SQR2_SQ9_Pos (24U) +#define ADC_SQR2_SQ9_Msk (0x1FUL << ADC_SQR2_SQ9_Pos) /*!< 0x1F000000 */ +#define ADC_SQR2_SQ9 ADC_SQR2_SQ9_Msk /*!< ADC group regular sequencer rank 9 */ +#define ADC_SQR2_SQ9_0 (0x01UL << ADC_SQR2_SQ9_Pos) /*!< 0x01000000 */ +#define ADC_SQR2_SQ9_1 (0x02UL << ADC_SQR2_SQ9_Pos) /*!< 0x02000000 */ +#define ADC_SQR2_SQ9_2 (0x04UL << ADC_SQR2_SQ9_Pos) /*!< 0x04000000 */ +#define ADC_SQR2_SQ9_3 (0x08UL << ADC_SQR2_SQ9_Pos) /*!< 0x08000000 */ +#define ADC_SQR2_SQ9_4 (0x10UL << ADC_SQR2_SQ9_Pos) /*!< 0x10000000 */ + +/******************** Bit definition for ADC_SQR3 register ******************/ +#define ADC_SQR3_SQ10_Pos (0U) +#define ADC_SQR3_SQ10_Msk (0x1FUL << ADC_SQR3_SQ10_Pos) /*!< 0x0000001F */ +#define ADC_SQR3_SQ10 ADC_SQR3_SQ10_Msk /*!< ADC group regular sequencer rank 10 */ +#define ADC_SQR3_SQ10_0 (0x01UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000001 */ +#define ADC_SQR3_SQ10_1 (0x02UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000002 */ +#define ADC_SQR3_SQ10_2 (0x04UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000004 */ +#define ADC_SQR3_SQ10_3 (0x08UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000008 */ +#define ADC_SQR3_SQ10_4 (0x10UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000010 */ + +#define ADC_SQR3_SQ11_Pos (6U) +#define ADC_SQR3_SQ11_Msk (0x1FUL << ADC_SQR3_SQ11_Pos) /*!< 0x000007C0 */ +#define ADC_SQR3_SQ11 ADC_SQR3_SQ11_Msk /*!< ADC group regular sequencer rank 11 */ +#define ADC_SQR3_SQ11_0 (0x01UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000040 */ +#define ADC_SQR3_SQ11_1 (0x02UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000080 */ +#define ADC_SQR3_SQ11_2 (0x04UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000100 */ +#define ADC_SQR3_SQ11_3 (0x08UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000200 */ +#define ADC_SQR3_SQ11_4 (0x10UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000400 */ + +#define ADC_SQR3_SQ12_Pos (12U) +#define ADC_SQR3_SQ12_Msk (0x1FUL << ADC_SQR3_SQ12_Pos) /*!< 0x0001F000 */ +#define ADC_SQR3_SQ12 ADC_SQR3_SQ12_Msk /*!< ADC group regular sequencer rank 12 */ +#define ADC_SQR3_SQ12_0 (0x01UL << ADC_SQR3_SQ12_Pos) /*!< 0x00001000 */ +#define ADC_SQR3_SQ12_1 (0x02UL << ADC_SQR3_SQ12_Pos) /*!< 0x00002000 */ +#define ADC_SQR3_SQ12_2 (0x04UL << ADC_SQR3_SQ12_Pos) /*!< 0x00004000 */ +#define ADC_SQR3_SQ12_3 (0x08UL << ADC_SQR3_SQ12_Pos) /*!< 0x00008000 */ +#define ADC_SQR3_SQ12_4 (0x10UL << ADC_SQR3_SQ12_Pos) /*!< 0x00010000 */ + +#define ADC_SQR3_SQ13_Pos (18U) +#define ADC_SQR3_SQ13_Msk (0x1FUL << ADC_SQR3_SQ13_Pos) /*!< 0x007C0000 */ +#define ADC_SQR3_SQ13 ADC_SQR3_SQ13_Msk /*!< ADC group regular sequencer rank 13 */ +#define ADC_SQR3_SQ13_0 (0x01UL << ADC_SQR3_SQ13_Pos) /*!< 0x00040000 */ +#define ADC_SQR3_SQ13_1 (0x02UL << ADC_SQR3_SQ13_Pos) /*!< 0x00080000 */ +#define ADC_SQR3_SQ13_2 (0x04UL << ADC_SQR3_SQ13_Pos) /*!< 0x00100000 */ +#define ADC_SQR3_SQ13_3 (0x08UL << ADC_SQR3_SQ13_Pos) /*!< 0x00200000 */ +#define ADC_SQR3_SQ13_4 (0x10UL << ADC_SQR3_SQ13_Pos) /*!< 0x00400000 */ + +#define ADC_SQR3_SQ14_Pos (24U) +#define ADC_SQR3_SQ14_Msk (0x1FUL << ADC_SQR3_SQ14_Pos) /*!< 0x1F000000 */ +#define ADC_SQR3_SQ14 ADC_SQR3_SQ14_Msk /*!< ADC group regular sequencer rank 14 */ +#define ADC_SQR3_SQ14_0 (0x01UL << ADC_SQR3_SQ14_Pos) /*!< 0x01000000 */ +#define ADC_SQR3_SQ14_1 (0x02UL << ADC_SQR3_SQ14_Pos) /*!< 0x02000000 */ +#define ADC_SQR3_SQ14_2 (0x04UL << ADC_SQR3_SQ14_Pos) /*!< 0x04000000 */ +#define ADC_SQR3_SQ14_3 (0x08UL << ADC_SQR3_SQ14_Pos) /*!< 0x08000000 */ +#define ADC_SQR3_SQ14_4 (0x10UL << ADC_SQR3_SQ14_Pos) /*!< 0x10000000 */ + +/******************** Bit definition for ADC_SQR4 register ******************/ +#define ADC_SQR4_SQ15_Pos (0U) +#define ADC_SQR4_SQ15_Msk (0x1FUL << ADC_SQR4_SQ15_Pos) /*!< 0x0000001F */ +#define ADC_SQR4_SQ15 ADC_SQR4_SQ15_Msk /*!< ADC group regular sequencer rank 15 */ +#define ADC_SQR4_SQ15_0 (0x01UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000001 */ +#define ADC_SQR4_SQ15_1 (0x02UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000002 */ +#define ADC_SQR4_SQ15_2 (0x04UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000004 */ +#define ADC_SQR4_SQ15_3 (0x08UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000008 */ +#define ADC_SQR4_SQ15_4 (0x10UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000010 */ + +#define ADC_SQR4_SQ16_Pos (6U) +#define ADC_SQR4_SQ16_Msk (0x1FUL << ADC_SQR4_SQ16_Pos) /*!< 0x000007C0 */ +#define ADC_SQR4_SQ16 ADC_SQR4_SQ16_Msk /*!< ADC group regular sequencer rank 16 */ +#define ADC_SQR4_SQ16_0 (0x01UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000040 */ +#define ADC_SQR4_SQ16_1 (0x02UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000080 */ +#define ADC_SQR4_SQ16_2 (0x04UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000100 */ +#define ADC_SQR4_SQ16_3 (0x08UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000200 */ +#define ADC_SQR4_SQ16_4 (0x10UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000400 */ + +/******************** Bit definition for ADC_DR register ********************/ +#define ADC_DR_RDATA_Pos (0U) +#define ADC_DR_RDATA_Msk (0xFFFFUL << ADC_DR_RDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_DR_RDATA ADC_DR_RDATA_Msk /*!< ADC group regular conversion data */ +#define ADC_DR_RDATA_0 (0x0001UL << ADC_DR_RDATA_Pos) /*!< 0x00000001 */ +#define ADC_DR_RDATA_1 (0x0002UL << ADC_DR_RDATA_Pos) /*!< 0x00000002 */ +#define ADC_DR_RDATA_2 (0x0004UL << ADC_DR_RDATA_Pos) /*!< 0x00000004 */ +#define ADC_DR_RDATA_3 (0x0008UL << ADC_DR_RDATA_Pos) /*!< 0x00000008 */ +#define ADC_DR_RDATA_4 (0x0010UL << ADC_DR_RDATA_Pos) /*!< 0x00000010 */ +#define ADC_DR_RDATA_5 (0x0020UL << ADC_DR_RDATA_Pos) /*!< 0x00000020 */ +#define ADC_DR_RDATA_6 (0x0040UL << ADC_DR_RDATA_Pos) /*!< 0x00000040 */ +#define ADC_DR_RDATA_7 (0x0080UL << ADC_DR_RDATA_Pos) /*!< 0x00000080 */ +#define ADC_DR_RDATA_8 (0x0100UL << ADC_DR_RDATA_Pos) /*!< 0x00000100 */ +#define ADC_DR_RDATA_9 (0x0200UL << ADC_DR_RDATA_Pos) /*!< 0x00000200 */ +#define ADC_DR_RDATA_10 (0x0400UL << ADC_DR_RDATA_Pos) /*!< 0x00000400 */ +#define ADC_DR_RDATA_11 (0x0800UL << ADC_DR_RDATA_Pos) /*!< 0x00000800 */ +#define ADC_DR_RDATA_12 (0x1000UL << ADC_DR_RDATA_Pos) /*!< 0x00001000 */ +#define ADC_DR_RDATA_13 (0x2000UL << ADC_DR_RDATA_Pos) /*!< 0x00002000 */ +#define ADC_DR_RDATA_14 (0x4000UL << ADC_DR_RDATA_Pos) /*!< 0x00004000 */ +#define ADC_DR_RDATA_15 (0x8000UL << ADC_DR_RDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JSQR register ******************/ +#define ADC_JSQR_JL_Pos (0U) +#define ADC_JSQR_JL_Msk (0x3UL << ADC_JSQR_JL_Pos) /*!< 0x00000003 */ +#define ADC_JSQR_JL ADC_JSQR_JL_Msk /*!< ADC group injected sequencer scan length */ +#define ADC_JSQR_JL_0 (0x1UL << ADC_JSQR_JL_Pos) /*!< 0x00000001 */ +#define ADC_JSQR_JL_1 (0x2UL << ADC_JSQR_JL_Pos) /*!< 0x00000002 */ + +#define ADC_JSQR_JEXTSEL_Pos (2U) +#define ADC_JSQR_JEXTSEL_Msk (0xFUL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x0000003C */ +#define ADC_JSQR_JEXTSEL ADC_JSQR_JEXTSEL_Msk /*!< ADC group injected external trigger source */ +#define ADC_JSQR_JEXTSEL_0 (0x1UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000004 */ +#define ADC_JSQR_JEXTSEL_1 (0x2UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000008 */ +#define ADC_JSQR_JEXTSEL_2 (0x4UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000010 */ +#define ADC_JSQR_JEXTSEL_3 (0x8UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000020 */ + +#define ADC_JSQR_JEXTEN_Pos (6U) +#define ADC_JSQR_JEXTEN_Msk (0x3UL << ADC_JSQR_JEXTEN_Pos) /*!< 0x000000C0 */ +#define ADC_JSQR_JEXTEN ADC_JSQR_JEXTEN_Msk /*!< ADC group injected external trigger polarity */ +#define ADC_JSQR_JEXTEN_0 (0x1UL << ADC_JSQR_JEXTEN_Pos) /*!< 0x00000040 */ +#define ADC_JSQR_JEXTEN_1 (0x2UL << ADC_JSQR_JEXTEN_Pos) /*!< 0x00000080 */ + +#define ADC_JSQR_JSQ1_Pos (8U) +#define ADC_JSQR_JSQ1_Msk (0x1FUL << ADC_JSQR_JSQ1_Pos) /*!< 0x00001F00 */ +#define ADC_JSQR_JSQ1 ADC_JSQR_JSQ1_Msk /*!< ADC group injected sequencer rank 1 */ +#define ADC_JSQR_JSQ1_0 (0x01UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000100 */ +#define ADC_JSQR_JSQ1_1 (0x02UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000200 */ +#define ADC_JSQR_JSQ1_2 (0x04UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000400 */ +#define ADC_JSQR_JSQ1_3 (0x08UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000800 */ +#define ADC_JSQR_JSQ1_4 (0x10UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00001000 */ + +#define ADC_JSQR_JSQ2_Pos (14U) +#define ADC_JSQR_JSQ2_Msk (0x1FUL << ADC_JSQR_JSQ2_Pos) /*!< 0x0007C000 */ +#define ADC_JSQR_JSQ2 ADC_JSQR_JSQ2_Msk /*!< ADC group injected sequencer rank 2 */ +#define ADC_JSQR_JSQ2_0 (0x01UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00004000 */ +#define ADC_JSQR_JSQ2_1 (0x02UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00008000 */ +#define ADC_JSQR_JSQ2_2 (0x04UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00010000 */ +#define ADC_JSQR_JSQ2_3 (0x08UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00020000 */ +#define ADC_JSQR_JSQ2_4 (0x10UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00040000 */ + +#define ADC_JSQR_JSQ3_Pos (20U) +#define ADC_JSQR_JSQ3_Msk (0x1FUL << ADC_JSQR_JSQ3_Pos) /*!< 0x01F00000 */ +#define ADC_JSQR_JSQ3 ADC_JSQR_JSQ3_Msk /*!< ADC group injected sequencer rank 3 */ +#define ADC_JSQR_JSQ3_0 (0x01UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00100000 */ +#define ADC_JSQR_JSQ3_1 (0x02UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00200000 */ +#define ADC_JSQR_JSQ3_2 (0x04UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00400000 */ +#define ADC_JSQR_JSQ3_3 (0x08UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00800000 */ +#define ADC_JSQR_JSQ3_4 (0x10UL << ADC_JSQR_JSQ3_Pos) /*!< 0x01000000 */ + +#define ADC_JSQR_JSQ4_Pos (26U) +#define ADC_JSQR_JSQ4_Msk (0x1FUL << ADC_JSQR_JSQ4_Pos) /*!< 0x7C000000 */ +#define ADC_JSQR_JSQ4 ADC_JSQR_JSQ4_Msk /*!< ADC group injected sequencer rank 4 */ +#define ADC_JSQR_JSQ4_0 (0x01UL << ADC_JSQR_JSQ4_Pos) /*!< 0x04000000 */ +#define ADC_JSQR_JSQ4_1 (0x02UL << ADC_JSQR_JSQ4_Pos) /*!< 0x08000000 */ +#define ADC_JSQR_JSQ4_2 (0x04UL << ADC_JSQR_JSQ4_Pos) /*!< 0x10000000 */ +#define ADC_JSQR_JSQ4_3 (0x08UL << ADC_JSQR_JSQ4_Pos) /*!< 0x20000000 */ +#define ADC_JSQR_JSQ4_4 (0x10UL << ADC_JSQR_JSQ4_Pos) /*!< 0x40000000 */ + +/******************** Bit definition for ADC_OFR1 register ******************/ +#define ADC_OFR1_OFFSET1_Pos (0U) +#define ADC_OFR1_OFFSET1_Msk (0xFFFUL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000FFF */ +#define ADC_OFR1_OFFSET1 ADC_OFR1_OFFSET1_Msk /*!< ADC offset number 1 offset level */ +#define ADC_OFR1_OFFSET1_0 (0x001UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000001 */ +#define ADC_OFR1_OFFSET1_1 (0x002UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000002 */ +#define ADC_OFR1_OFFSET1_2 (0x004UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000004 */ +#define ADC_OFR1_OFFSET1_3 (0x008UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000008 */ +#define ADC_OFR1_OFFSET1_4 (0x010UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000010 */ +#define ADC_OFR1_OFFSET1_5 (0x020UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000020 */ +#define ADC_OFR1_OFFSET1_6 (0x040UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000040 */ +#define ADC_OFR1_OFFSET1_7 (0x080UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000080 */ +#define ADC_OFR1_OFFSET1_8 (0x100UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000100 */ +#define ADC_OFR1_OFFSET1_9 (0x200UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000200 */ +#define ADC_OFR1_OFFSET1_10 (0x400UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000400 */ +#define ADC_OFR1_OFFSET1_11 (0x800UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000800 */ + +#define ADC_OFR1_OFFSET1_CH_Pos (26U) +#define ADC_OFR1_OFFSET1_CH_Msk (0x1FUL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR1_OFFSET1_CH ADC_OFR1_OFFSET1_CH_Msk /*!< ADC offset number 1 channel selection */ +#define ADC_OFR1_OFFSET1_CH_0 (0x01UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR1_OFFSET1_CH_1 (0x02UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR1_OFFSET1_CH_2 (0x04UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR1_OFFSET1_CH_3 (0x08UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR1_OFFSET1_CH_4 (0x10UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR1_OFFSET1_EN_Pos (31U) +#define ADC_OFR1_OFFSET1_EN_Msk (0x1UL << ADC_OFR1_OFFSET1_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR1_OFFSET1_EN ADC_OFR1_OFFSET1_EN_Msk /*!< ADC offset number 1 enable */ + +/******************** Bit definition for ADC_OFR2 register ******************/ +#define ADC_OFR2_OFFSET2_Pos (0U) +#define ADC_OFR2_OFFSET2_Msk (0xFFFUL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000FFF */ +#define ADC_OFR2_OFFSET2 ADC_OFR2_OFFSET2_Msk /*!< ADC offset number 2 offset level */ +#define ADC_OFR2_OFFSET2_0 (0x001UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000001 */ +#define ADC_OFR2_OFFSET2_1 (0x002UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000002 */ +#define ADC_OFR2_OFFSET2_2 (0x004UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000004 */ +#define ADC_OFR2_OFFSET2_3 (0x008UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000008 */ +#define ADC_OFR2_OFFSET2_4 (0x010UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000010 */ +#define ADC_OFR2_OFFSET2_5 (0x020UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000020 */ +#define ADC_OFR2_OFFSET2_6 (0x040UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000040 */ +#define ADC_OFR2_OFFSET2_7 (0x080UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000080 */ +#define ADC_OFR2_OFFSET2_8 (0x100UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000100 */ +#define ADC_OFR2_OFFSET2_9 (0x200UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000200 */ +#define ADC_OFR2_OFFSET2_10 (0x400UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000400 */ +#define ADC_OFR2_OFFSET2_11 (0x800UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000800 */ + +#define ADC_OFR2_OFFSET2_CH_Pos (26U) +#define ADC_OFR2_OFFSET2_CH_Msk (0x1FUL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR2_OFFSET2_CH ADC_OFR2_OFFSET2_CH_Msk /*!< ADC offset number 2 channel selection */ +#define ADC_OFR2_OFFSET2_CH_0 (0x01UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR2_OFFSET2_CH_1 (0x02UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR2_OFFSET2_CH_2 (0x04UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR2_OFFSET2_CH_3 (0x08UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR2_OFFSET2_CH_4 (0x10UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR2_OFFSET2_EN_Pos (31U) +#define ADC_OFR2_OFFSET2_EN_Msk (0x1UL << ADC_OFR2_OFFSET2_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR2_OFFSET2_EN ADC_OFR2_OFFSET2_EN_Msk /*!< ADC offset number 2 enable */ + +/******************** Bit definition for ADC_OFR3 register ******************/ +#define ADC_OFR3_OFFSET3_Pos (0U) +#define ADC_OFR3_OFFSET3_Msk (0xFFFUL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000FFF */ +#define ADC_OFR3_OFFSET3 ADC_OFR3_OFFSET3_Msk /*!< ADC offset number 3 offset level */ +#define ADC_OFR3_OFFSET3_0 (0x001UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000001 */ +#define ADC_OFR3_OFFSET3_1 (0x002UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000002 */ +#define ADC_OFR3_OFFSET3_2 (0x004UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000004 */ +#define ADC_OFR3_OFFSET3_3 (0x008UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000008 */ +#define ADC_OFR3_OFFSET3_4 (0x010UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000010 */ +#define ADC_OFR3_OFFSET3_5 (0x020UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000020 */ +#define ADC_OFR3_OFFSET3_6 (0x040UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000040 */ +#define ADC_OFR3_OFFSET3_7 (0x080UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000080 */ +#define ADC_OFR3_OFFSET3_8 (0x100UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000100 */ +#define ADC_OFR3_OFFSET3_9 (0x200UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000200 */ +#define ADC_OFR3_OFFSET3_10 (0x400UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000400 */ +#define ADC_OFR3_OFFSET3_11 (0x800UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000800 */ + +#define ADC_OFR3_OFFSET3_CH_Pos (26U) +#define ADC_OFR3_OFFSET3_CH_Msk (0x1FUL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR3_OFFSET3_CH ADC_OFR3_OFFSET3_CH_Msk /*!< ADC offset number 3 channel selection */ +#define ADC_OFR3_OFFSET3_CH_0 (0x01UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR3_OFFSET3_CH_1 (0x02UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR3_OFFSET3_CH_2 (0x04UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR3_OFFSET3_CH_3 (0x08UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR3_OFFSET3_CH_4 (0x10UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR3_OFFSET3_EN_Pos (31U) +#define ADC_OFR3_OFFSET3_EN_Msk (0x1UL << ADC_OFR3_OFFSET3_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR3_OFFSET3_EN ADC_OFR3_OFFSET3_EN_Msk /*!< ADC offset number 3 enable */ + +/******************** Bit definition for ADC_OFR4 register ******************/ +#define ADC_OFR4_OFFSET4_Pos (0U) +#define ADC_OFR4_OFFSET4_Msk (0xFFFUL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000FFF */ +#define ADC_OFR4_OFFSET4 ADC_OFR4_OFFSET4_Msk /*!< ADC offset number 4 offset level */ +#define ADC_OFR4_OFFSET4_0 (0x001UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000001 */ +#define ADC_OFR4_OFFSET4_1 (0x002UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000002 */ +#define ADC_OFR4_OFFSET4_2 (0x004UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000004 */ +#define ADC_OFR4_OFFSET4_3 (0x008UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000008 */ +#define ADC_OFR4_OFFSET4_4 (0x010UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000010 */ +#define ADC_OFR4_OFFSET4_5 (0x020UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000020 */ +#define ADC_OFR4_OFFSET4_6 (0x040UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000040 */ +#define ADC_OFR4_OFFSET4_7 (0x080UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000080 */ +#define ADC_OFR4_OFFSET4_8 (0x100UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000100 */ +#define ADC_OFR4_OFFSET4_9 (0x200UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000200 */ +#define ADC_OFR4_OFFSET4_10 (0x400UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000400 */ +#define ADC_OFR4_OFFSET4_11 (0x800UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000800 */ + +#define ADC_OFR4_OFFSET4_CH_Pos (26U) +#define ADC_OFR4_OFFSET4_CH_Msk (0x1FUL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR4_OFFSET4_CH ADC_OFR4_OFFSET4_CH_Msk /*!< ADC offset number 4 channel selection */ +#define ADC_OFR4_OFFSET4_CH_0 (0x01UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR4_OFFSET4_CH_1 (0x02UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR4_OFFSET4_CH_2 (0x04UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR4_OFFSET4_CH_3 (0x08UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR4_OFFSET4_CH_4 (0x10UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR4_OFFSET4_EN_Pos (31U) +#define ADC_OFR4_OFFSET4_EN_Msk (0x1UL << ADC_OFR4_OFFSET4_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR4_OFFSET4_EN ADC_OFR4_OFFSET4_EN_Msk /*!< ADC offset number 4 enable */ + +/******************** Bit definition for ADC_JDR1 register ******************/ +#define ADC_JDR1_JDATA_Pos (0U) +#define ADC_JDR1_JDATA_Msk (0xFFFFUL << ADC_JDR1_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR1_JDATA ADC_JDR1_JDATA_Msk /*!< ADC group injected sequencer rank 1 conversion data */ +#define ADC_JDR1_JDATA_0 (0x0001UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR1_JDATA_1 (0x0002UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR1_JDATA_2 (0x0004UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR1_JDATA_3 (0x0008UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR1_JDATA_4 (0x0010UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR1_JDATA_5 (0x0020UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR1_JDATA_6 (0x0040UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR1_JDATA_7 (0x0080UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR1_JDATA_8 (0x0100UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR1_JDATA_9 (0x0200UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR1_JDATA_10 (0x0400UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR1_JDATA_11 (0x0800UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR1_JDATA_12 (0x1000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR1_JDATA_13 (0x2000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR1_JDATA_14 (0x4000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR1_JDATA_15 (0x8000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JDR2 register ******************/ +#define ADC_JDR2_JDATA_Pos (0U) +#define ADC_JDR2_JDATA_Msk (0xFFFFUL << ADC_JDR2_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR2_JDATA ADC_JDR2_JDATA_Msk /*!< ADC group injected sequencer rank 2 conversion data */ +#define ADC_JDR2_JDATA_0 (0x0001UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR2_JDATA_1 (0x0002UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR2_JDATA_2 (0x0004UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR2_JDATA_3 (0x0008UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR2_JDATA_4 (0x0010UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR2_JDATA_5 (0x0020UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR2_JDATA_6 (0x0040UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR2_JDATA_7 (0x0080UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR2_JDATA_8 (0x0100UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR2_JDATA_9 (0x0200UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR2_JDATA_10 (0x0400UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR2_JDATA_11 (0x0800UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR2_JDATA_12 (0x1000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR2_JDATA_13 (0x2000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR2_JDATA_14 (0x4000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR2_JDATA_15 (0x8000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JDR3 register ******************/ +#define ADC_JDR3_JDATA_Pos (0U) +#define ADC_JDR3_JDATA_Msk (0xFFFFUL << ADC_JDR3_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR3_JDATA ADC_JDR3_JDATA_Msk /*!< ADC group injected sequencer rank 3 conversion data */ +#define ADC_JDR3_JDATA_0 (0x0001UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR3_JDATA_1 (0x0002UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR3_JDATA_2 (0x0004UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR3_JDATA_3 (0x0008UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR3_JDATA_4 (0x0010UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR3_JDATA_5 (0x0020UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR3_JDATA_6 (0x0040UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR3_JDATA_7 (0x0080UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR3_JDATA_8 (0x0100UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR3_JDATA_9 (0x0200UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR3_JDATA_10 (0x0400UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR3_JDATA_11 (0x0800UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR3_JDATA_12 (0x1000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR3_JDATA_13 (0x2000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR3_JDATA_14 (0x4000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR3_JDATA_15 (0x8000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JDR4 register ******************/ +#define ADC_JDR4_JDATA_Pos (0U) +#define ADC_JDR4_JDATA_Msk (0xFFFFUL << ADC_JDR4_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR4_JDATA ADC_JDR4_JDATA_Msk /*!< ADC group injected sequencer rank 4 conversion data */ +#define ADC_JDR4_JDATA_0 (0x0001UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR4_JDATA_1 (0x0002UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR4_JDATA_2 (0x0004UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR4_JDATA_3 (0x0008UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR4_JDATA_4 (0x0010UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR4_JDATA_5 (0x0020UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR4_JDATA_6 (0x0040UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR4_JDATA_7 (0x0080UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR4_JDATA_8 (0x0100UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR4_JDATA_9 (0x0200UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR4_JDATA_10 (0x0400UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR4_JDATA_11 (0x0800UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR4_JDATA_12 (0x1000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR4_JDATA_13 (0x2000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR4_JDATA_14 (0x4000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR4_JDATA_15 (0x8000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_AWD2CR register ****************/ +#define ADC_AWD2CR_AWD2CH_Pos (0U) +#define ADC_AWD2CR_AWD2CH_Msk (0x7FFFFUL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x0007FFFF */ +#define ADC_AWD2CR_AWD2CH ADC_AWD2CR_AWD2CH_Msk /*!< ADC analog watchdog 2 monitored channel selection */ +#define ADC_AWD2CR_AWD2CH_0 (0x00001UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000001 */ +#define ADC_AWD2CR_AWD2CH_1 (0x00002UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000002 */ +#define ADC_AWD2CR_AWD2CH_2 (0x00004UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000004 */ +#define ADC_AWD2CR_AWD2CH_3 (0x00008UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000008 */ +#define ADC_AWD2CR_AWD2CH_4 (0x00010UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000010 */ +#define ADC_AWD2CR_AWD2CH_5 (0x00020UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000020 */ +#define ADC_AWD2CR_AWD2CH_6 (0x00040UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000040 */ +#define ADC_AWD2CR_AWD2CH_7 (0x00080UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000080 */ +#define ADC_AWD2CR_AWD2CH_8 (0x00100UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000100 */ +#define ADC_AWD2CR_AWD2CH_9 (0x00200UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000200 */ +#define ADC_AWD2CR_AWD2CH_10 (0x00400UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000400 */ +#define ADC_AWD2CR_AWD2CH_11 (0x00800UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000800 */ +#define ADC_AWD2CR_AWD2CH_12 (0x01000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00001000 */ +#define ADC_AWD2CR_AWD2CH_13 (0x02000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00002000 */ +#define ADC_AWD2CR_AWD2CH_14 (0x04000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00004000 */ +#define ADC_AWD2CR_AWD2CH_15 (0x08000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00008000 */ +#define ADC_AWD2CR_AWD2CH_16 (0x10000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00010000 */ +#define ADC_AWD2CR_AWD2CH_17 (0x20000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00020000 */ +#define ADC_AWD2CR_AWD2CH_18 (0x40000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00040000 */ + +/******************** Bit definition for ADC_AWD3CR register ****************/ +#define ADC_AWD3CR_AWD3CH_Pos (0U) +#define ADC_AWD3CR_AWD3CH_Msk (0x7FFFFUL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x0007FFFF */ +#define ADC_AWD3CR_AWD3CH ADC_AWD3CR_AWD3CH_Msk /*!< ADC analog watchdog 3 monitored channel selection */ +#define ADC_AWD3CR_AWD3CH_0 (0x00001UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000001 */ +#define ADC_AWD3CR_AWD3CH_1 (0x00002UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000002 */ +#define ADC_AWD3CR_AWD3CH_2 (0x00004UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000004 */ +#define ADC_AWD3CR_AWD3CH_3 (0x00008UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000008 */ +#define ADC_AWD3CR_AWD3CH_4 (0x00010UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000010 */ +#define ADC_AWD3CR_AWD3CH_5 (0x00020UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000020 */ +#define ADC_AWD3CR_AWD3CH_6 (0x00040UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000040 */ +#define ADC_AWD3CR_AWD3CH_7 (0x00080UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000080 */ +#define ADC_AWD3CR_AWD3CH_8 (0x00100UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000100 */ +#define ADC_AWD3CR_AWD3CH_9 (0x00200UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000200 */ +#define ADC_AWD3CR_AWD3CH_10 (0x00400UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000400 */ +#define ADC_AWD3CR_AWD3CH_11 (0x00800UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000800 */ +#define ADC_AWD3CR_AWD3CH_12 (0x01000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00001000 */ +#define ADC_AWD3CR_AWD3CH_13 (0x02000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00002000 */ +#define ADC_AWD3CR_AWD3CH_14 (0x04000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00004000 */ +#define ADC_AWD3CR_AWD3CH_15 (0x08000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00008000 */ +#define ADC_AWD3CR_AWD3CH_16 (0x10000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00010000 */ +#define ADC_AWD3CR_AWD3CH_17 (0x20000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00020000 */ +#define ADC_AWD3CR_AWD3CH_18 (0x40000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00040000 */ + +/******************** Bit definition for ADC_DIFSEL register ****************/ +#define ADC_DIFSEL_DIFSEL_Pos (0U) +#define ADC_DIFSEL_DIFSEL_Msk (0x7FFFFUL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x0007FFFF */ +#define ADC_DIFSEL_DIFSEL ADC_DIFSEL_DIFSEL_Msk /*!< ADC channel differential or single-ended mode */ +#define ADC_DIFSEL_DIFSEL_0 (0x00001UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000001 */ +#define ADC_DIFSEL_DIFSEL_1 (0x00002UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000002 */ +#define ADC_DIFSEL_DIFSEL_2 (0x00004UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000004 */ +#define ADC_DIFSEL_DIFSEL_3 (0x00008UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000008 */ +#define ADC_DIFSEL_DIFSEL_4 (0x00010UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000010 */ +#define ADC_DIFSEL_DIFSEL_5 (0x00020UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000020 */ +#define ADC_DIFSEL_DIFSEL_6 (0x00040UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000040 */ +#define ADC_DIFSEL_DIFSEL_7 (0x00080UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000080 */ +#define ADC_DIFSEL_DIFSEL_8 (0x00100UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000100 */ +#define ADC_DIFSEL_DIFSEL_9 (0x00200UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000200 */ +#define ADC_DIFSEL_DIFSEL_10 (0x00400UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000400 */ +#define ADC_DIFSEL_DIFSEL_11 (0x00800UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000800 */ +#define ADC_DIFSEL_DIFSEL_12 (0x01000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00001000 */ +#define ADC_DIFSEL_DIFSEL_13 (0x02000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00002000 */ +#define ADC_DIFSEL_DIFSEL_14 (0x04000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00004000 */ +#define ADC_DIFSEL_DIFSEL_15 (0x08000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00008000 */ +#define ADC_DIFSEL_DIFSEL_16 (0x10000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00010000 */ +#define ADC_DIFSEL_DIFSEL_17 (0x20000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00020000 */ +#define ADC_DIFSEL_DIFSEL_18 (0x40000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00040000 */ + +/******************** Bit definition for ADC_CALFACT register ***************/ +#define ADC_CALFACT_CALFACT_S_Pos (0U) +#define ADC_CALFACT_CALFACT_S_Msk (0x7FUL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x0000007F */ +#define ADC_CALFACT_CALFACT_S ADC_CALFACT_CALFACT_S_Msk /*!< ADC calibration factor in single-ended mode */ +#define ADC_CALFACT_CALFACT_S_0 (0x01UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000001 */ +#define ADC_CALFACT_CALFACT_S_1 (0x02UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000002 */ +#define ADC_CALFACT_CALFACT_S_2 (0x04UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000004 */ +#define ADC_CALFACT_CALFACT_S_3 (0x08UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000008 */ +#define ADC_CALFACT_CALFACT_S_4 (0x10UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000010 */ +#define ADC_CALFACT_CALFACT_S_5 (0x20UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000020 */ +#define ADC_CALFACT_CALFACT_S_6 (0x40UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000040 */ + +#define ADC_CALFACT_CALFACT_D_Pos (16U) +#define ADC_CALFACT_CALFACT_D_Msk (0x7FUL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x007F0000 */ +#define ADC_CALFACT_CALFACT_D ADC_CALFACT_CALFACT_D_Msk /*!< ADC calibration factor in differential mode */ +#define ADC_CALFACT_CALFACT_D_0 (0x01UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00010000 */ +#define ADC_CALFACT_CALFACT_D_1 (0x02UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00020000 */ +#define ADC_CALFACT_CALFACT_D_2 (0x04UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00040000 */ +#define ADC_CALFACT_CALFACT_D_3 (0x08UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00080000 */ +#define ADC_CALFACT_CALFACT_D_4 (0x10UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00100000 */ +#define ADC_CALFACT_CALFACT_D_5 (0x20UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00200000 */ +#define ADC_CALFACT_CALFACT_D_6 (0x40UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00400000 */ + +/************************* ADC Common registers *****************************/ +/******************** Bit definition for ADC_CSR register *******************/ +#define ADC_CSR_ADRDY_MST_Pos (0U) +#define ADC_CSR_ADRDY_MST_Msk (0x1UL << ADC_CSR_ADRDY_MST_Pos) /*!< 0x00000001 */ +#define ADC_CSR_ADRDY_MST ADC_CSR_ADRDY_MST_Msk /*!< ADC multimode master ready flag */ +#define ADC_CSR_EOSMP_MST_Pos (1U) +#define ADC_CSR_EOSMP_MST_Msk (0x1UL << ADC_CSR_EOSMP_MST_Pos) /*!< 0x00000002 */ +#define ADC_CSR_EOSMP_MST ADC_CSR_EOSMP_MST_Msk /*!< ADC multimode master group regular end of sampling flag */ +#define ADC_CSR_EOC_MST_Pos (2U) +#define ADC_CSR_EOC_MST_Msk (0x1UL << ADC_CSR_EOC_MST_Pos) /*!< 0x00000004 */ +#define ADC_CSR_EOC_MST ADC_CSR_EOC_MST_Msk /*!< ADC multimode master group regular end of unitary conversion flag */ +#define ADC_CSR_EOS_MST_Pos (3U) +#define ADC_CSR_EOS_MST_Msk (0x1UL << ADC_CSR_EOS_MST_Pos) /*!< 0x00000008 */ +#define ADC_CSR_EOS_MST ADC_CSR_EOS_MST_Msk /*!< ADC multimode master group regular end of sequence conversions flag */ +#define ADC_CSR_OVR_MST_Pos (4U) +#define ADC_CSR_OVR_MST_Msk (0x1UL << ADC_CSR_OVR_MST_Pos) /*!< 0x00000010 */ +#define ADC_CSR_OVR_MST ADC_CSR_OVR_MST_Msk /*!< ADC multimode master group regular overrun flag */ +#define ADC_CSR_JEOC_MST_Pos (5U) +#define ADC_CSR_JEOC_MST_Msk (0x1UL << ADC_CSR_JEOC_MST_Pos) /*!< 0x00000020 */ +#define ADC_CSR_JEOC_MST ADC_CSR_JEOC_MST_Msk /*!< ADC multimode master group injected end of unitary conversion flag */ +#define ADC_CSR_JEOS_MST_Pos (6U) +#define ADC_CSR_JEOS_MST_Msk (0x1UL << ADC_CSR_JEOS_MST_Pos) /*!< 0x00000040 */ +#define ADC_CSR_JEOS_MST ADC_CSR_JEOS_MST_Msk /*!< ADC multimode master group injected end of sequence conversions flag */ +#define ADC_CSR_AWD1_MST_Pos (7U) +#define ADC_CSR_AWD1_MST_Msk (0x1UL << ADC_CSR_AWD1_MST_Pos) /*!< 0x00000080 */ +#define ADC_CSR_AWD1_MST ADC_CSR_AWD1_MST_Msk /*!< ADC multimode master analog watchdog 1 flag */ +#define ADC_CSR_AWD2_MST_Pos (8U) +#define ADC_CSR_AWD2_MST_Msk (0x1UL << ADC_CSR_AWD2_MST_Pos) /*!< 0x00000100 */ +#define ADC_CSR_AWD2_MST ADC_CSR_AWD2_MST_Msk /*!< ADC multimode master analog watchdog 2 flag */ +#define ADC_CSR_AWD3_MST_Pos (9U) +#define ADC_CSR_AWD3_MST_Msk (0x1UL << ADC_CSR_AWD3_MST_Pos) /*!< 0x00000200 */ +#define ADC_CSR_AWD3_MST ADC_CSR_AWD3_MST_Msk /*!< ADC multimode master analog watchdog 3 flag */ +#define ADC_CSR_JQOVF_MST_Pos (10U) +#define ADC_CSR_JQOVF_MST_Msk (0x1UL << ADC_CSR_JQOVF_MST_Pos) /*!< 0x00000400 */ +#define ADC_CSR_JQOVF_MST ADC_CSR_JQOVF_MST_Msk /*!< ADC multimode master group injected contexts queue overflow flag */ + +#define ADC_CSR_ADRDY_SLV_Pos (16U) +#define ADC_CSR_ADRDY_SLV_Msk (0x1UL << ADC_CSR_ADRDY_SLV_Pos) /*!< 0x00010000 */ +#define ADC_CSR_ADRDY_SLV ADC_CSR_ADRDY_SLV_Msk /*!< ADC multimode slave ready flag */ +#define ADC_CSR_EOSMP_SLV_Pos (17U) +#define ADC_CSR_EOSMP_SLV_Msk (0x1UL << ADC_CSR_EOSMP_SLV_Pos) /*!< 0x00020000 */ +#define ADC_CSR_EOSMP_SLV ADC_CSR_EOSMP_SLV_Msk /*!< ADC multimode slave group regular end of sampling flag */ +#define ADC_CSR_EOC_SLV_Pos (18U) +#define ADC_CSR_EOC_SLV_Msk (0x1UL << ADC_CSR_EOC_SLV_Pos) /*!< 0x00040000 */ +#define ADC_CSR_EOC_SLV ADC_CSR_EOC_SLV_Msk /*!< ADC multimode slave group regular end of unitary conversion flag */ +#define ADC_CSR_EOS_SLV_Pos (19U) +#define ADC_CSR_EOS_SLV_Msk (0x1UL << ADC_CSR_EOS_SLV_Pos) /*!< 0x00080000 */ +#define ADC_CSR_EOS_SLV ADC_CSR_EOS_SLV_Msk /*!< ADC multimode slave group regular end of sequence conversions flag */ +#define ADC_CSR_OVR_SLV_Pos (20U) +#define ADC_CSR_OVR_SLV_Msk (0x1UL << ADC_CSR_OVR_SLV_Pos) /*!< 0x00100000 */ +#define ADC_CSR_OVR_SLV ADC_CSR_OVR_SLV_Msk /*!< ADC multimode slave group regular overrun flag */ +#define ADC_CSR_JEOC_SLV_Pos (21U) +#define ADC_CSR_JEOC_SLV_Msk (0x1UL << ADC_CSR_JEOC_SLV_Pos) /*!< 0x00200000 */ +#define ADC_CSR_JEOC_SLV ADC_CSR_JEOC_SLV_Msk /*!< ADC multimode slave group injected end of unitary conversion flag */ +#define ADC_CSR_JEOS_SLV_Pos (22U) +#define ADC_CSR_JEOS_SLV_Msk (0x1UL << ADC_CSR_JEOS_SLV_Pos) /*!< 0x00400000 */ +#define ADC_CSR_JEOS_SLV ADC_CSR_JEOS_SLV_Msk /*!< ADC multimode slave group injected end of sequence conversions flag */ +#define ADC_CSR_AWD1_SLV_Pos (23U) +#define ADC_CSR_AWD1_SLV_Msk (0x1UL << ADC_CSR_AWD1_SLV_Pos) /*!< 0x00800000 */ +#define ADC_CSR_AWD1_SLV ADC_CSR_AWD1_SLV_Msk /*!< ADC multimode slave analog watchdog 1 flag */ +#define ADC_CSR_AWD2_SLV_Pos (24U) +#define ADC_CSR_AWD2_SLV_Msk (0x1UL << ADC_CSR_AWD2_SLV_Pos) /*!< 0x01000000 */ +#define ADC_CSR_AWD2_SLV ADC_CSR_AWD2_SLV_Msk /*!< ADC multimode slave analog watchdog 2 flag */ +#define ADC_CSR_AWD3_SLV_Pos (25U) +#define ADC_CSR_AWD3_SLV_Msk (0x1UL << ADC_CSR_AWD3_SLV_Pos) /*!< 0x02000000 */ +#define ADC_CSR_AWD3_SLV ADC_CSR_AWD3_SLV_Msk /*!< ADC multimode slave analog watchdog 3 flag */ +#define ADC_CSR_JQOVF_SLV_Pos (26U) +#define ADC_CSR_JQOVF_SLV_Msk (0x1UL << ADC_CSR_JQOVF_SLV_Pos) /*!< 0x04000000 */ +#define ADC_CSR_JQOVF_SLV ADC_CSR_JQOVF_SLV_Msk /*!< ADC multimode slave group injected contexts queue overflow flag */ + +/******************** Bit definition for ADC_CCR register *******************/ +#define ADC_CCR_DUAL_Pos (0U) +#define ADC_CCR_DUAL_Msk (0x1FUL << ADC_CCR_DUAL_Pos) /*!< 0x0000001F */ +#define ADC_CCR_DUAL ADC_CCR_DUAL_Msk /*!< ADC multimode mode selection */ +#define ADC_CCR_DUAL_0 (0x01UL << ADC_CCR_DUAL_Pos) /*!< 0x00000001 */ +#define ADC_CCR_DUAL_1 (0x02UL << ADC_CCR_DUAL_Pos) /*!< 0x00000002 */ +#define ADC_CCR_DUAL_2 (0x04UL << ADC_CCR_DUAL_Pos) /*!< 0x00000004 */ +#define ADC_CCR_DUAL_3 (0x08UL << ADC_CCR_DUAL_Pos) /*!< 0x00000008 */ +#define ADC_CCR_DUAL_4 (0x10UL << ADC_CCR_DUAL_Pos) /*!< 0x00000010 */ + +#define ADC_CCR_DELAY_Pos (8U) +#define ADC_CCR_DELAY_Msk (0xFUL << ADC_CCR_DELAY_Pos) /*!< 0x00000F00 */ +#define ADC_CCR_DELAY ADC_CCR_DELAY_Msk /*!< ADC multimode delay between 2 sampling phases */ +#define ADC_CCR_DELAY_0 (0x1UL << ADC_CCR_DELAY_Pos) /*!< 0x00000100 */ +#define ADC_CCR_DELAY_1 (0x2UL << ADC_CCR_DELAY_Pos) /*!< 0x00000200 */ +#define ADC_CCR_DELAY_2 (0x4UL << ADC_CCR_DELAY_Pos) /*!< 0x00000400 */ +#define ADC_CCR_DELAY_3 (0x8UL << ADC_CCR_DELAY_Pos) /*!< 0x00000800 */ + +#define ADC_CCR_DMACFG_Pos (13U) +#define ADC_CCR_DMACFG_Msk (0x1UL << ADC_CCR_DMACFG_Pos) /*!< 0x00002000 */ +#define ADC_CCR_DMACFG ADC_CCR_DMACFG_Msk /*!< ADC multimode DMA transfer configuration */ + +#define ADC_CCR_MDMA_Pos (14U) +#define ADC_CCR_MDMA_Msk (0x3UL << ADC_CCR_MDMA_Pos) /*!< 0x0000C000 */ +#define ADC_CCR_MDMA ADC_CCR_MDMA_Msk /*!< ADC multimode DMA transfer enable */ +#define ADC_CCR_MDMA_0 (0x1UL << ADC_CCR_MDMA_Pos) /*!< 0x00004000 */ +#define ADC_CCR_MDMA_1 (0x2UL << ADC_CCR_MDMA_Pos) /*!< 0x00008000 */ + +#define ADC_CCR_CKMODE_Pos (16U) +#define ADC_CCR_CKMODE_Msk (0x3UL << ADC_CCR_CKMODE_Pos) /*!< 0x00030000 */ +#define ADC_CCR_CKMODE ADC_CCR_CKMODE_Msk /*!< ADC common clock source and prescaler (prescaler only for clock source synchronous) */ +#define ADC_CCR_CKMODE_0 (0x1UL << ADC_CCR_CKMODE_Pos) /*!< 0x00010000 */ +#define ADC_CCR_CKMODE_1 (0x2UL << ADC_CCR_CKMODE_Pos) /*!< 0x00020000 */ + +#define ADC_CCR_PRESC_Pos (18U) +#define ADC_CCR_PRESC_Msk (0xFUL << ADC_CCR_PRESC_Pos) /*!< 0x003C0000 */ +#define ADC_CCR_PRESC ADC_CCR_PRESC_Msk /*!< ADC common clock prescaler, only for clock source asynchronous */ +#define ADC_CCR_PRESC_0 (0x1UL << ADC_CCR_PRESC_Pos) /*!< 0x00040000 */ +#define ADC_CCR_PRESC_1 (0x2UL << ADC_CCR_PRESC_Pos) /*!< 0x00080000 */ +#define ADC_CCR_PRESC_2 (0x4UL << ADC_CCR_PRESC_Pos) /*!< 0x00100000 */ +#define ADC_CCR_PRESC_3 (0x8UL << ADC_CCR_PRESC_Pos) /*!< 0x00200000 */ + +#define ADC_CCR_VREFEN_Pos (22U) +#define ADC_CCR_VREFEN_Msk (0x1UL << ADC_CCR_VREFEN_Pos) /*!< 0x00400000 */ +#define ADC_CCR_VREFEN ADC_CCR_VREFEN_Msk /*!< ADC internal path to VrefInt enable */ +#define ADC_CCR_TSEN_Pos (23U) +#define ADC_CCR_TSEN_Msk (0x1UL << ADC_CCR_TSEN_Pos) /*!< 0x00800000 */ +#define ADC_CCR_TSEN ADC_CCR_TSEN_Msk /*!< ADC internal path to temperature sensor enable */ +#define ADC_CCR_VBATEN_Pos (24U) +#define ADC_CCR_VBATEN_Msk (0x1UL << ADC_CCR_VBATEN_Pos) /*!< 0x01000000 */ +#define ADC_CCR_VBATEN ADC_CCR_VBATEN_Msk /*!< ADC internal path to battery voltage enable */ + +/******************** Bit definition for ADC_CDR register *******************/ +#define ADC_CDR_RDATA_MST_Pos (0U) +#define ADC_CDR_RDATA_MST_Msk (0xFFFFUL << ADC_CDR_RDATA_MST_Pos) /*!< 0x0000FFFF */ +#define ADC_CDR_RDATA_MST ADC_CDR_RDATA_MST_Msk /*!< ADC multimode master group regular conversion data */ +#define ADC_CDR_RDATA_MST_0 (0x0001UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000001 */ +#define ADC_CDR_RDATA_MST_1 (0x0002UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000002 */ +#define ADC_CDR_RDATA_MST_2 (0x0004UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000004 */ +#define ADC_CDR_RDATA_MST_3 (0x0008UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000008 */ +#define ADC_CDR_RDATA_MST_4 (0x0010UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000010 */ +#define ADC_CDR_RDATA_MST_5 (0x0020UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000020 */ +#define ADC_CDR_RDATA_MST_6 (0x0040UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000040 */ +#define ADC_CDR_RDATA_MST_7 (0x0080UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000080 */ +#define ADC_CDR_RDATA_MST_8 (0x0100UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000100 */ +#define ADC_CDR_RDATA_MST_9 (0x0200UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000200 */ +#define ADC_CDR_RDATA_MST_10 (0x0400UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000400 */ +#define ADC_CDR_RDATA_MST_11 (0x0800UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000800 */ +#define ADC_CDR_RDATA_MST_12 (0x1000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00001000 */ +#define ADC_CDR_RDATA_MST_13 (0x2000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00002000 */ +#define ADC_CDR_RDATA_MST_14 (0x4000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00004000 */ +#define ADC_CDR_RDATA_MST_15 (0x8000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00008000 */ + +#define ADC_CDR_RDATA_SLV_Pos (16U) +#define ADC_CDR_RDATA_SLV_Msk (0xFFFFUL << ADC_CDR_RDATA_SLV_Pos) /*!< 0xFFFF0000 */ +#define ADC_CDR_RDATA_SLV ADC_CDR_RDATA_SLV_Msk /*!< ADC multimode slave group regular conversion data */ +#define ADC_CDR_RDATA_SLV_0 (0x0001UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00010000 */ +#define ADC_CDR_RDATA_SLV_1 (0x0002UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00020000 */ +#define ADC_CDR_RDATA_SLV_2 (0x0004UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00040000 */ +#define ADC_CDR_RDATA_SLV_3 (0x0008UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00080000 */ +#define ADC_CDR_RDATA_SLV_4 (0x0010UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00100000 */ +#define ADC_CDR_RDATA_SLV_5 (0x0020UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00200000 */ +#define ADC_CDR_RDATA_SLV_6 (0x0040UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00400000 */ +#define ADC_CDR_RDATA_SLV_7 (0x0080UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00800000 */ +#define ADC_CDR_RDATA_SLV_8 (0x0100UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x01000000 */ +#define ADC_CDR_RDATA_SLV_9 (0x0200UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x02000000 */ +#define ADC_CDR_RDATA_SLV_10 (0x0400UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x04000000 */ +#define ADC_CDR_RDATA_SLV_11 (0x0800UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x08000000 */ +#define ADC_CDR_RDATA_SLV_12 (0x1000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x10000000 */ +#define ADC_CDR_RDATA_SLV_13 (0x2000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x20000000 */ +#define ADC_CDR_RDATA_SLV_14 (0x4000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x40000000 */ +#define ADC_CDR_RDATA_SLV_15 (0x8000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x80000000 */ + + +/******************************************************************************/ +/* */ +/* CRC calculation unit */ +/* */ +/******************************************************************************/ +/******************* Bit definition for CRC_DR register *********************/ +#define CRC_DR_DR_Pos (0U) +#define CRC_DR_DR_Msk (0xFFFFFFFFUL << CRC_DR_DR_Pos) /*!< 0xFFFFFFFF */ +#define CRC_DR_DR CRC_DR_DR_Msk /*!< Data register bits */ + +/******************* Bit definition for CRC_IDR register ********************/ +#define CRC_IDR_IDR_Pos (0U) +#define CRC_IDR_IDR_Msk (0xFFU << CRC_IDR_IDR_Pos) /*!< 0x000000FF */ +#define CRC_IDR_IDR CRC_IDR_IDR_Msk /*!< General-purpose 8-bit data register bits */ + +/******************** Bit definition for CRC_CR register ********************/ +#define CRC_CR_RESET_Pos (0U) +#define CRC_CR_RESET_Msk (0x1UL << CRC_CR_RESET_Pos) /*!< 0x00000001 */ +#define CRC_CR_RESET CRC_CR_RESET_Msk /*!< RESET the CRC computation unit bit */ +#define CRC_CR_POLYSIZE_Pos (3U) +#define CRC_CR_POLYSIZE_Msk (0x3UL << CRC_CR_POLYSIZE_Pos) /*!< 0x00000018 */ +#define CRC_CR_POLYSIZE CRC_CR_POLYSIZE_Msk /*!< Polynomial size bits */ +#define CRC_CR_POLYSIZE_0 (0x1UL << CRC_CR_POLYSIZE_Pos) /*!< 0x00000008 */ +#define CRC_CR_POLYSIZE_1 (0x2UL << CRC_CR_POLYSIZE_Pos) /*!< 0x00000010 */ +#define CRC_CR_REV_IN_Pos (5U) +#define CRC_CR_REV_IN_Msk (0x3UL << CRC_CR_REV_IN_Pos) /*!< 0x00000060 */ +#define CRC_CR_REV_IN CRC_CR_REV_IN_Msk /*!< REV_IN Reverse Input Data bits */ +#define CRC_CR_REV_IN_0 (0x1UL << CRC_CR_REV_IN_Pos) /*!< 0x00000020 */ +#define CRC_CR_REV_IN_1 (0x2UL << CRC_CR_REV_IN_Pos) /*!< 0x00000040 */ +#define CRC_CR_REV_OUT_Pos (7U) +#define CRC_CR_REV_OUT_Msk (0x1UL << CRC_CR_REV_OUT_Pos) /*!< 0x00000080 */ +#define CRC_CR_REV_OUT CRC_CR_REV_OUT_Msk /*!< REV_OUT Reverse Output Data bits */ + +/******************* Bit definition for CRC_INIT register *******************/ +#define CRC_INIT_INIT_Pos (0U) +#define CRC_INIT_INIT_Msk (0xFFFFFFFFUL << CRC_INIT_INIT_Pos) /*!< 0xFFFFFFFF */ +#define CRC_INIT_INIT CRC_INIT_INIT_Msk /*!< Initial CRC value bits */ + +/******************* Bit definition for CRC_POL register ********************/ +#define CRC_POL_POL_Pos (0U) +#define CRC_POL_POL_Msk (0xFFFFFFFFUL << CRC_POL_POL_Pos) /*!< 0xFFFFFFFF */ +#define CRC_POL_POL CRC_POL_POL_Msk /*!< Coefficients of the polynomial */ + +/******************************************************************************/ +/* */ +/* CRS Clock Recovery System */ +/******************************************************************************/ + +/******************* Bit definition for CRS_CR register *********************/ +#define CRS_CR_SYNCOKIE_Pos (0U) +#define CRS_CR_SYNCOKIE_Msk (0x1UL << CRS_CR_SYNCOKIE_Pos) /*!< 0x00000001 */ +#define CRS_CR_SYNCOKIE CRS_CR_SYNCOKIE_Msk /*!< SYNC event OK interrupt enable */ +#define CRS_CR_SYNCWARNIE_Pos (1U) +#define CRS_CR_SYNCWARNIE_Msk (0x1UL << CRS_CR_SYNCWARNIE_Pos) /*!< 0x00000002 */ +#define CRS_CR_SYNCWARNIE CRS_CR_SYNCWARNIE_Msk /*!< SYNC warning interrupt enable */ +#define CRS_CR_ERRIE_Pos (2U) +#define CRS_CR_ERRIE_Msk (0x1UL << CRS_CR_ERRIE_Pos) /*!< 0x00000004 */ +#define CRS_CR_ERRIE CRS_CR_ERRIE_Msk /*!< SYNC error or trimming error interrupt enable */ +#define CRS_CR_ESYNCIE_Pos (3U) +#define CRS_CR_ESYNCIE_Msk (0x1UL << CRS_CR_ESYNCIE_Pos) /*!< 0x00000008 */ +#define CRS_CR_ESYNCIE CRS_CR_ESYNCIE_Msk /*!< Expected SYNC interrupt enable */ +#define CRS_CR_CEN_Pos (5U) +#define CRS_CR_CEN_Msk (0x1UL << CRS_CR_CEN_Pos) /*!< 0x00000020 */ +#define CRS_CR_CEN CRS_CR_CEN_Msk /*!< Frequency error counter enable */ +#define CRS_CR_AUTOTRIMEN_Pos (6U) +#define CRS_CR_AUTOTRIMEN_Msk (0x1UL << CRS_CR_AUTOTRIMEN_Pos) /*!< 0x00000040 */ +#define CRS_CR_AUTOTRIMEN CRS_CR_AUTOTRIMEN_Msk /*!< Automatic trimming enable */ +#define CRS_CR_SWSYNC_Pos (7U) +#define CRS_CR_SWSYNC_Msk (0x1UL << CRS_CR_SWSYNC_Pos) /*!< 0x00000080 */ +#define CRS_CR_SWSYNC CRS_CR_SWSYNC_Msk /*!< Generate software SYNC event */ +#define CRS_CR_TRIM_Pos (8U) +#define CRS_CR_TRIM_Msk (0x7FUL << CRS_CR_TRIM_Pos) /*!< 0x00007F00 */ +#define CRS_CR_TRIM CRS_CR_TRIM_Msk /*!< TRIM[6:0] HSI48 oscillator smooth trimming */ +#define CRS_CR_TRIM_0 (0x01UL << CRS_CR_TRIM_Pos) /*!< 0x00000100 */ +#define CRS_CR_TRIM_1 (0x02UL << CRS_CR_TRIM_Pos) /*!< 0x00000200 */ +#define CRS_CR_TRIM_2 (0x04UL << CRS_CR_TRIM_Pos) /*!< 0x00000400 */ +#define CRS_CR_TRIM_3 (0x08UL << CRS_CR_TRIM_Pos) /*!< 0x00000800 */ +#define CRS_CR_TRIM_4 (0x10UL << CRS_CR_TRIM_Pos) /*!< 0x00001000 */ +#define CRS_CR_TRIM_5 (0x20UL << CRS_CR_TRIM_Pos) /*!< 0x00002000 */ +#define CRS_CR_TRIM_6 (0x40UL << CRS_CR_TRIM_Pos) /*!< 0x00004000 */ + +/******************* Bit definition for CRS_CFGR register *********************/ +#define CRS_CFGR_RELOAD_Pos (0U) +#define CRS_CFGR_RELOAD_Msk (0xFFFFUL << CRS_CFGR_RELOAD_Pos) /*!< 0x0000FFFF */ +#define CRS_CFGR_RELOAD CRS_CFGR_RELOAD_Msk /*!< Counter reload value */ +#define CRS_CFGR_FELIM_Pos (16U) +#define CRS_CFGR_FELIM_Msk (0xFFUL << CRS_CFGR_FELIM_Pos) /*!< 0x00FF0000 */ +#define CRS_CFGR_FELIM CRS_CFGR_FELIM_Msk /*!< Frequency error limit */ + +#define CRS_CFGR_SYNCDIV_Pos (24U) +#define CRS_CFGR_SYNCDIV_Msk (0x7UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x07000000 */ +#define CRS_CFGR_SYNCDIV CRS_CFGR_SYNCDIV_Msk /*!< SYNC divider */ +#define CRS_CFGR_SYNCDIV_0 (0x1UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x01000000 */ +#define CRS_CFGR_SYNCDIV_1 (0x2UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x02000000 */ +#define CRS_CFGR_SYNCDIV_2 (0x4UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x04000000 */ + +#define CRS_CFGR_SYNCSRC_Pos (28U) +#define CRS_CFGR_SYNCSRC_Msk (0x3UL << CRS_CFGR_SYNCSRC_Pos) /*!< 0x30000000 */ +#define CRS_CFGR_SYNCSRC CRS_CFGR_SYNCSRC_Msk /*!< SYNC signal source selection */ +#define CRS_CFGR_SYNCSRC_0 (0x1UL << CRS_CFGR_SYNCSRC_Pos) /*!< 0x10000000 */ +#define CRS_CFGR_SYNCSRC_1 (0x2UL << CRS_CFGR_SYNCSRC_Pos) /*!< 0x20000000 */ + +#define CRS_CFGR_SYNCPOL_Pos (31U) +#define CRS_CFGR_SYNCPOL_Msk (0x1UL << CRS_CFGR_SYNCPOL_Pos) /*!< 0x80000000 */ +#define CRS_CFGR_SYNCPOL CRS_CFGR_SYNCPOL_Msk /*!< SYNC polarity selection */ + +/******************* Bit definition for CRS_ISR register *********************/ +#define CRS_ISR_SYNCOKF_Pos (0U) +#define CRS_ISR_SYNCOKF_Msk (0x1UL << CRS_ISR_SYNCOKF_Pos) /*!< 0x00000001 */ +#define CRS_ISR_SYNCOKF CRS_ISR_SYNCOKF_Msk /*!< SYNC event OK flag */ +#define CRS_ISR_SYNCWARNF_Pos (1U) +#define CRS_ISR_SYNCWARNF_Msk (0x1UL << CRS_ISR_SYNCWARNF_Pos) /*!< 0x00000002 */ +#define CRS_ISR_SYNCWARNF CRS_ISR_SYNCWARNF_Msk /*!< SYNC warning flag */ +#define CRS_ISR_ERRF_Pos (2U) +#define CRS_ISR_ERRF_Msk (0x1UL << CRS_ISR_ERRF_Pos) /*!< 0x00000004 */ +#define CRS_ISR_ERRF CRS_ISR_ERRF_Msk /*!< Error flag */ +#define CRS_ISR_ESYNCF_Pos (3U) +#define CRS_ISR_ESYNCF_Msk (0x1UL << CRS_ISR_ESYNCF_Pos) /*!< 0x00000008 */ +#define CRS_ISR_ESYNCF CRS_ISR_ESYNCF_Msk /*!< Expected SYNC flag */ +#define CRS_ISR_SYNCERR_Pos (8U) +#define CRS_ISR_SYNCERR_Msk (0x1UL << CRS_ISR_SYNCERR_Pos) /*!< 0x00000100 */ +#define CRS_ISR_SYNCERR CRS_ISR_SYNCERR_Msk /*!< SYNC error */ +#define CRS_ISR_SYNCMISS_Pos (9U) +#define CRS_ISR_SYNCMISS_Msk (0x1UL << CRS_ISR_SYNCMISS_Pos) /*!< 0x00000200 */ +#define CRS_ISR_SYNCMISS CRS_ISR_SYNCMISS_Msk /*!< SYNC missed */ +#define CRS_ISR_TRIMOVF_Pos (10U) +#define CRS_ISR_TRIMOVF_Msk (0x1UL << CRS_ISR_TRIMOVF_Pos) /*!< 0x00000400 */ +#define CRS_ISR_TRIMOVF CRS_ISR_TRIMOVF_Msk /*!< Trimming overflow or underflow */ +#define CRS_ISR_FEDIR_Pos (15U) +#define CRS_ISR_FEDIR_Msk (0x1UL << CRS_ISR_FEDIR_Pos) /*!< 0x00008000 */ +#define CRS_ISR_FEDIR CRS_ISR_FEDIR_Msk /*!< Frequency error direction */ +#define CRS_ISR_FECAP_Pos (16U) +#define CRS_ISR_FECAP_Msk (0xFFFFUL << CRS_ISR_FECAP_Pos) /*!< 0xFFFF0000 */ +#define CRS_ISR_FECAP CRS_ISR_FECAP_Msk /*!< Frequency error capture */ + +/******************* Bit definition for CRS_ICR register *********************/ +#define CRS_ICR_SYNCOKC_Pos (0U) +#define CRS_ICR_SYNCOKC_Msk (0x1UL << CRS_ICR_SYNCOKC_Pos) /*!< 0x00000001 */ +#define CRS_ICR_SYNCOKC CRS_ICR_SYNCOKC_Msk /*!< SYNC event OK clear flag */ +#define CRS_ICR_SYNCWARNC_Pos (1U) +#define CRS_ICR_SYNCWARNC_Msk (0x1UL << CRS_ICR_SYNCWARNC_Pos) /*!< 0x00000002 */ +#define CRS_ICR_SYNCWARNC CRS_ICR_SYNCWARNC_Msk /*!< SYNC warning clear flag */ +#define CRS_ICR_ERRC_Pos (2U) +#define CRS_ICR_ERRC_Msk (0x1UL << CRS_ICR_ERRC_Pos) /*!< 0x00000004 */ +#define CRS_ICR_ERRC CRS_ICR_ERRC_Msk /*!< Error clear flag */ +#define CRS_ICR_ESYNCC_Pos (3U) +#define CRS_ICR_ESYNCC_Msk (0x1UL << CRS_ICR_ESYNCC_Pos) /*!< 0x00000008 */ +#define CRS_ICR_ESYNCC CRS_ICR_ESYNCC_Msk /*!< Expected SYNC clear flag */ + +/******************************************************************************/ +/* */ +/* Advanced Encryption Standard (AES) */ +/* */ +/******************************************************************************/ +/******************* Bit definition for AES_CR register *********************/ +#define AES_CR_EN_Pos (0U) +#define AES_CR_EN_Msk (0x1UL << AES_CR_EN_Pos) /*!< 0x00000001 */ +#define AES_CR_EN AES_CR_EN_Msk /*!< AES Enable */ +#define AES_CR_DATATYPE_Pos (1U) +#define AES_CR_DATATYPE_Msk (0x3UL << AES_CR_DATATYPE_Pos) /*!< 0x00000006 */ +#define AES_CR_DATATYPE AES_CR_DATATYPE_Msk /*!< Data type selection */ +#define AES_CR_DATATYPE_0 (0x1UL << AES_CR_DATATYPE_Pos) /*!< 0x00000002 */ +#define AES_CR_DATATYPE_1 (0x2UL << AES_CR_DATATYPE_Pos) /*!< 0x00000004 */ + +#define AES_CR_MODE_Pos (3U) +#define AES_CR_MODE_Msk (0x3UL << AES_CR_MODE_Pos) /*!< 0x00000018 */ +#define AES_CR_MODE AES_CR_MODE_Msk /*!< AES Mode Of Operation */ +#define AES_CR_MODE_0 (0x1UL << AES_CR_MODE_Pos) /*!< 0x00000008 */ +#define AES_CR_MODE_1 (0x2UL << AES_CR_MODE_Pos) /*!< 0x00000010 */ + +#define AES_CR_CHMOD_Pos (5U) +#define AES_CR_CHMOD_Msk (0x803UL << AES_CR_CHMOD_Pos) /*!< 0x00010060 */ +#define AES_CR_CHMOD AES_CR_CHMOD_Msk /*!< AES Chaining Mode */ +#define AES_CR_CHMOD_0 (0x001UL << AES_CR_CHMOD_Pos) /*!< 0x00000020 */ +#define AES_CR_CHMOD_1 (0x002UL << AES_CR_CHMOD_Pos) /*!< 0x00000040 */ +#define AES_CR_CHMOD_2 (0x800UL << AES_CR_CHMOD_Pos) /*!< 0x00010000 */ + +#define AES_CR_CCFC_Pos (7U) +#define AES_CR_CCFC_Msk (0x1UL << AES_CR_CCFC_Pos) /*!< 0x00000080 */ +#define AES_CR_CCFC AES_CR_CCFC_Msk /*!< Computation Complete Flag Clear */ +#define AES_CR_ERRC_Pos (8U) +#define AES_CR_ERRC_Msk (0x1UL << AES_CR_ERRC_Pos) /*!< 0x00000100 */ +#define AES_CR_ERRC AES_CR_ERRC_Msk /*!< Error Clear */ +#define AES_CR_CCFIE_Pos (9U) +#define AES_CR_CCFIE_Msk (0x1UL << AES_CR_CCFIE_Pos) /*!< 0x00000200 */ +#define AES_CR_CCFIE AES_CR_CCFIE_Msk /*!< Computation Complete Flag Interrupt Enable */ +#define AES_CR_ERRIE_Pos (10U) +#define AES_CR_ERRIE_Msk (0x1UL << AES_CR_ERRIE_Pos) /*!< 0x00000400 */ +#define AES_CR_ERRIE AES_CR_ERRIE_Msk /*!< Error Interrupt Enable */ +#define AES_CR_DMAINEN_Pos (11U) +#define AES_CR_DMAINEN_Msk (0x1UL << AES_CR_DMAINEN_Pos) /*!< 0x00000800 */ +#define AES_CR_DMAINEN AES_CR_DMAINEN_Msk /*!< Enable data input phase DMA management */ +#define AES_CR_DMAOUTEN_Pos (12U) +#define AES_CR_DMAOUTEN_Msk (0x1UL << AES_CR_DMAOUTEN_Pos) /*!< 0x00001000 */ +#define AES_CR_DMAOUTEN AES_CR_DMAOUTEN_Msk /*!< Enable data output phase DMA management */ + +#define AES_CR_GCMPH_Pos (13U) +#define AES_CR_GCMPH_Msk (0x3UL << AES_CR_GCMPH_Pos) /*!< 0x00006000 */ +#define AES_CR_GCMPH AES_CR_GCMPH_Msk /*!< GCM Phase */ +#define AES_CR_GCMPH_0 (0x1UL << AES_CR_GCMPH_Pos) /*!< 0x00002000 */ +#define AES_CR_GCMPH_1 (0x2UL << AES_CR_GCMPH_Pos) /*!< 0x00004000 */ + +#define AES_CR_KEYSIZE_Pos (18U) +#define AES_CR_KEYSIZE_Msk (0x1UL << AES_CR_KEYSIZE_Pos) /*!< 0x00040000 */ +#define AES_CR_KEYSIZE AES_CR_KEYSIZE_Msk /*!< Key size selection */ + +/******************* Bit definition for AES_SR register *********************/ +#define AES_SR_CCF_Pos (0U) +#define AES_SR_CCF_Msk (0x1UL << AES_SR_CCF_Pos) /*!< 0x00000001 */ +#define AES_SR_CCF AES_SR_CCF_Msk /*!< Computation Complete Flag */ +#define AES_SR_RDERR_Pos (1U) +#define AES_SR_RDERR_Msk (0x1UL << AES_SR_RDERR_Pos) /*!< 0x00000002 */ +#define AES_SR_RDERR AES_SR_RDERR_Msk /*!< Read Error Flag */ +#define AES_SR_WRERR_Pos (2U) +#define AES_SR_WRERR_Msk (0x1UL << AES_SR_WRERR_Pos) /*!< 0x00000004 */ +#define AES_SR_WRERR AES_SR_WRERR_Msk /*!< Write Error Flag */ +#define AES_SR_BUSY_Pos (3U) +#define AES_SR_BUSY_Msk (0x1UL << AES_SR_BUSY_Pos) /*!< 0x00000008 */ +#define AES_SR_BUSY AES_SR_BUSY_Msk /*!< Busy Flag */ + +/******************* Bit definition for AES_DINR register *******************/ +#define AES_DINR_Pos (0U) +#define AES_DINR_Msk (0xFFFFFFFFUL << AES_DINR_Pos) /*!< 0xFFFFFFFF */ +#define AES_DINR AES_DINR_Msk /*!< AES Data Input Register */ + +/******************* Bit definition for AES_DOUTR register ******************/ +#define AES_DOUTR_Pos (0U) +#define AES_DOUTR_Msk (0xFFFFFFFFUL << AES_DOUTR_Pos) /*!< 0xFFFFFFFF */ +#define AES_DOUTR AES_DOUTR_Msk /*!< AES Data Output Register */ + +/******************* Bit definition for AES_KEYR0 register ******************/ +#define AES_KEYR0_Pos (0U) +#define AES_KEYR0_Msk (0xFFFFFFFFUL << AES_KEYR0_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR0 AES_KEYR0_Msk /*!< AES Key Register 0 */ + +/******************* Bit definition for AES_KEYR1 register ******************/ +#define AES_KEYR1_Pos (0U) +#define AES_KEYR1_Msk (0xFFFFFFFFUL << AES_KEYR1_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR1 AES_KEYR1_Msk /*!< AES Key Register 1 */ + +/******************* Bit definition for AES_KEYR2 register ******************/ +#define AES_KEYR2_Pos (0U) +#define AES_KEYR2_Msk (0xFFFFFFFFUL << AES_KEYR2_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR2 AES_KEYR2_Msk /*!< AES Key Register 2 */ + +/******************* Bit definition for AES_KEYR3 register ******************/ +#define AES_KEYR3_Pos (0U) +#define AES_KEYR3_Msk (0xFFFFFFFFUL << AES_KEYR3_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR3 AES_KEYR3_Msk /*!< AES Key Register 3 */ + +/******************* Bit definition for AES_KEYR4 register ******************/ +#define AES_KEYR4_Pos (0U) +#define AES_KEYR4_Msk (0xFFFFFFFFUL << AES_KEYR4_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR4 AES_KEYR4_Msk /*!< AES Key Register 4 */ + +/******************* Bit definition for AES_KEYR5 register ******************/ +#define AES_KEYR5_Pos (0U) +#define AES_KEYR5_Msk (0xFFFFFFFFUL << AES_KEYR5_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR5 AES_KEYR5_Msk /*!< AES Key Register 5 */ + +/******************* Bit definition for AES_KEYR6 register ******************/ +#define AES_KEYR6_Pos (0U) +#define AES_KEYR6_Msk (0xFFFFFFFFUL << AES_KEYR6_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR6 AES_KEYR6_Msk /*!< AES Key Register 6 */ + +/******************* Bit definition for AES_KEYR7 register ******************/ +#define AES_KEYR7_Pos (0U) +#define AES_KEYR7_Msk (0xFFFFFFFFUL << AES_KEYR7_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR7 AES_KEYR7_Msk /*!< AES Key Register 7 */ + +/******************* Bit definition for AES_IVR0 register ******************/ +#define AES_IVR0_Pos (0U) +#define AES_IVR0_Msk (0xFFFFFFFFUL << AES_IVR0_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR0 AES_IVR0_Msk /*!< AES Initialization Vector Register 0 */ + +/******************* Bit definition for AES_IVR1 register ******************/ +#define AES_IVR1_Pos (0U) +#define AES_IVR1_Msk (0xFFFFFFFFUL << AES_IVR1_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR1 AES_IVR1_Msk /*!< AES Initialization Vector Register 1 */ + +/******************* Bit definition for AES_IVR2 register ******************/ +#define AES_IVR2_Pos (0U) +#define AES_IVR2_Msk (0xFFFFFFFFUL << AES_IVR2_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR2 AES_IVR2_Msk /*!< AES Initialization Vector Register 2 */ + +/******************* Bit definition for AES_IVR3 register ******************/ +#define AES_IVR3_Pos (0U) +#define AES_IVR3_Msk (0xFFFFFFFFUL << AES_IVR3_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR3 AES_IVR3_Msk /*!< AES Initialization Vector Register 3 */ + +/******************* Bit definition for AES_SUSP0R register ******************/ +#define AES_SUSP0R_Pos (0U) +#define AES_SUSP0R_Msk (0xFFFFFFFFUL << AES_SUSP0R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP0R AES_SUSP0R_Msk /*!< AES Suspend registers 0 */ + +/******************* Bit definition for AES_SUSP1R register ******************/ +#define AES_SUSP1R_Pos (0U) +#define AES_SUSP1R_Msk (0xFFFFFFFFUL << AES_SUSP1R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP1R AES_SUSP1R_Msk /*!< AES Suspend registers 1 */ + +/******************* Bit definition for AES_SUSP2R register ******************/ +#define AES_SUSP2R_Pos (0U) +#define AES_SUSP2R_Msk (0xFFFFFFFFUL << AES_SUSP2R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP2R AES_SUSP2R_Msk /*!< AES Suspend registers 2 */ + +/******************* Bit definition for AES_SUSP3R register ******************/ +#define AES_SUSP3R_Pos (0U) +#define AES_SUSP3R_Msk (0xFFFFFFFFUL << AES_SUSP3R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP3R AES_SUSP3R_Msk /*!< AES Suspend registers 3 */ + +/******************* Bit definition for AES_SUSP4R register ******************/ +#define AES_SUSP4R_Pos (0U) +#define AES_SUSP4R_Msk (0xFFFFFFFFUL << AES_SUSP4R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP4R AES_SUSP4R_Msk /*!< AES Suspend registers 4 */ + +/******************* Bit definition for AES_SUSP5R register ******************/ +#define AES_SUSP5R_Pos (0U) +#define AES_SUSP5R_Msk (0xFFFFFFFFUL << AES_SUSP5R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP5R AES_SUSP5R_Msk /*!< AES Suspend registers 5 */ + +/******************* Bit definition for AES_SUSP6R register ******************/ +#define AES_SUSP6R_Pos (0U) +#define AES_SUSP6R_Msk (0xFFFFFFFFUL << AES_SUSP6R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP6R AES_SUSP6R_Msk /*!< AES Suspend registers 6 */ + +/******************* Bit definition for AES_SUSP7R register ******************/ +#define AES_SUSP7R_Pos (0U) +#define AES_SUSP7R_Msk (0xFFFFFFFFUL << AES_SUSP7R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP7R AES_SUSP7R_Msk /*!< AES Suspend registers 7 */ + + +/******************************************************************************/ +/* */ +/* DMA Controller (DMA) */ +/* */ +/******************************************************************************/ + +/******************* Bit definition for DMA_ISR register ********************/ +#define DMA_ISR_GIF1_Pos (0U) +#define DMA_ISR_GIF1_Msk (0x1UL << DMA_ISR_GIF1_Pos) /*!< 0x00000001 */ +#define DMA_ISR_GIF1 DMA_ISR_GIF1_Msk /*!< Channel 1 Global interrupt flag */ +#define DMA_ISR_TCIF1_Pos (1U) +#define DMA_ISR_TCIF1_Msk (0x1UL << DMA_ISR_TCIF1_Pos) /*!< 0x00000002 */ +#define DMA_ISR_TCIF1 DMA_ISR_TCIF1_Msk /*!< Channel 1 Transfer Complete flag */ +#define DMA_ISR_HTIF1_Pos (2U) +#define DMA_ISR_HTIF1_Msk (0x1UL << DMA_ISR_HTIF1_Pos) /*!< 0x00000004 */ +#define DMA_ISR_HTIF1 DMA_ISR_HTIF1_Msk /*!< Channel 1 Half Transfer flag */ +#define DMA_ISR_TEIF1_Pos (3U) +#define DMA_ISR_TEIF1_Msk (0x1UL << DMA_ISR_TEIF1_Pos) /*!< 0x00000008 */ +#define DMA_ISR_TEIF1 DMA_ISR_TEIF1_Msk /*!< Channel 1 Transfer Error flag */ +#define DMA_ISR_GIF2_Pos (4U) +#define DMA_ISR_GIF2_Msk (0x1UL << DMA_ISR_GIF2_Pos) /*!< 0x00000010 */ +#define DMA_ISR_GIF2 DMA_ISR_GIF2_Msk /*!< Channel 2 Global interrupt flag */ +#define DMA_ISR_TCIF2_Pos (5U) +#define DMA_ISR_TCIF2_Msk (0x1UL << DMA_ISR_TCIF2_Pos) /*!< 0x00000020 */ +#define DMA_ISR_TCIF2 DMA_ISR_TCIF2_Msk /*!< Channel 2 Transfer Complete flag */ +#define DMA_ISR_HTIF2_Pos (6U) +#define DMA_ISR_HTIF2_Msk (0x1UL << DMA_ISR_HTIF2_Pos) /*!< 0x00000040 */ +#define DMA_ISR_HTIF2 DMA_ISR_HTIF2_Msk /*!< Channel 2 Half Transfer flag */ +#define DMA_ISR_TEIF2_Pos (7U) +#define DMA_ISR_TEIF2_Msk (0x1UL << DMA_ISR_TEIF2_Pos) /*!< 0x00000080 */ +#define DMA_ISR_TEIF2 DMA_ISR_TEIF2_Msk /*!< Channel 2 Transfer Error flag */ +#define DMA_ISR_GIF3_Pos (8U) +#define DMA_ISR_GIF3_Msk (0x1UL << DMA_ISR_GIF3_Pos) /*!< 0x00000100 */ +#define DMA_ISR_GIF3 DMA_ISR_GIF3_Msk /*!< Channel 3 Global interrupt flag */ +#define DMA_ISR_TCIF3_Pos (9U) +#define DMA_ISR_TCIF3_Msk (0x1UL << DMA_ISR_TCIF3_Pos) /*!< 0x00000200 */ +#define DMA_ISR_TCIF3 DMA_ISR_TCIF3_Msk /*!< Channel 3 Transfer Complete flag */ +#define DMA_ISR_HTIF3_Pos (10U) +#define DMA_ISR_HTIF3_Msk (0x1UL << DMA_ISR_HTIF3_Pos) /*!< 0x00000400 */ +#define DMA_ISR_HTIF3 DMA_ISR_HTIF3_Msk /*!< Channel 3 Half Transfer flag */ +#define DMA_ISR_TEIF3_Pos (11U) +#define DMA_ISR_TEIF3_Msk (0x1UL << DMA_ISR_TEIF3_Pos) /*!< 0x00000800 */ +#define DMA_ISR_TEIF3 DMA_ISR_TEIF3_Msk /*!< Channel 3 Transfer Error flag */ +#define DMA_ISR_GIF4_Pos (12U) +#define DMA_ISR_GIF4_Msk (0x1UL << DMA_ISR_GIF4_Pos) /*!< 0x00001000 */ +#define DMA_ISR_GIF4 DMA_ISR_GIF4_Msk /*!< Channel 4 Global interrupt flag */ +#define DMA_ISR_TCIF4_Pos (13U) +#define DMA_ISR_TCIF4_Msk (0x1UL << DMA_ISR_TCIF4_Pos) /*!< 0x00002000 */ +#define DMA_ISR_TCIF4 DMA_ISR_TCIF4_Msk /*!< Channel 4 Transfer Complete flag */ +#define DMA_ISR_HTIF4_Pos (14U) +#define DMA_ISR_HTIF4_Msk (0x1UL << DMA_ISR_HTIF4_Pos) /*!< 0x00004000 */ +#define DMA_ISR_HTIF4 DMA_ISR_HTIF4_Msk /*!< Channel 4 Half Transfer flag */ +#define DMA_ISR_TEIF4_Pos (15U) +#define DMA_ISR_TEIF4_Msk (0x1UL << DMA_ISR_TEIF4_Pos) /*!< 0x00008000 */ +#define DMA_ISR_TEIF4 DMA_ISR_TEIF4_Msk /*!< Channel 4 Transfer Error flag */ +#define DMA_ISR_GIF5_Pos (16U) +#define DMA_ISR_GIF5_Msk (0x1UL << DMA_ISR_GIF5_Pos) /*!< 0x00010000 */ +#define DMA_ISR_GIF5 DMA_ISR_GIF5_Msk /*!< Channel 5 Global interrupt flag */ +#define DMA_ISR_TCIF5_Pos (17U) +#define DMA_ISR_TCIF5_Msk (0x1UL << DMA_ISR_TCIF5_Pos) /*!< 0x00020000 */ +#define DMA_ISR_TCIF5 DMA_ISR_TCIF5_Msk /*!< Channel 5 Transfer Complete flag */ +#define DMA_ISR_HTIF5_Pos (18U) +#define DMA_ISR_HTIF5_Msk (0x1UL << DMA_ISR_HTIF5_Pos) /*!< 0x00040000 */ +#define DMA_ISR_HTIF5 DMA_ISR_HTIF5_Msk /*!< Channel 5 Half Transfer flag */ +#define DMA_ISR_TEIF5_Pos (19U) +#define DMA_ISR_TEIF5_Msk (0x1UL << DMA_ISR_TEIF5_Pos) /*!< 0x00080000 */ +#define DMA_ISR_TEIF5 DMA_ISR_TEIF5_Msk /*!< Channel 5 Transfer Error flag */ +#define DMA_ISR_GIF6_Pos (20U) +#define DMA_ISR_GIF6_Msk (0x1UL << DMA_ISR_GIF6_Pos) /*!< 0x00100000 */ +#define DMA_ISR_GIF6 DMA_ISR_GIF6_Msk /*!< Channel 6 Global interrupt flag */ +#define DMA_ISR_TCIF6_Pos (21U) +#define DMA_ISR_TCIF6_Msk (0x1UL << DMA_ISR_TCIF6_Pos) /*!< 0x00200000 */ +#define DMA_ISR_TCIF6 DMA_ISR_TCIF6_Msk /*!< Channel 6 Transfer Complete flag */ +#define DMA_ISR_HTIF6_Pos (22U) +#define DMA_ISR_HTIF6_Msk (0x1UL << DMA_ISR_HTIF6_Pos) /*!< 0x00400000 */ +#define DMA_ISR_HTIF6 DMA_ISR_HTIF6_Msk /*!< Channel 6 Half Transfer flag */ +#define DMA_ISR_TEIF6_Pos (23U) +#define DMA_ISR_TEIF6_Msk (0x1UL << DMA_ISR_TEIF6_Pos) /*!< 0x00800000 */ +#define DMA_ISR_TEIF6 DMA_ISR_TEIF6_Msk /*!< Channel 6 Transfer Error flag */ +#define DMA_ISR_GIF7_Pos (24U) +#define DMA_ISR_GIF7_Msk (0x1UL << DMA_ISR_GIF7_Pos) /*!< 0x01000000 */ +#define DMA_ISR_GIF7 DMA_ISR_GIF7_Msk /*!< Channel 7 Global interrupt flag */ +#define DMA_ISR_TCIF7_Pos (25U) +#define DMA_ISR_TCIF7_Msk (0x1UL << DMA_ISR_TCIF7_Pos) /*!< 0x02000000 */ +#define DMA_ISR_TCIF7 DMA_ISR_TCIF7_Msk /*!< Channel 7 Transfer Complete flag */ +#define DMA_ISR_HTIF7_Pos (26U) +#define DMA_ISR_HTIF7_Msk (0x1UL << DMA_ISR_HTIF7_Pos) /*!< 0x04000000 */ +#define DMA_ISR_HTIF7 DMA_ISR_HTIF7_Msk /*!< Channel 7 Half Transfer flag */ +#define DMA_ISR_TEIF7_Pos (27U) +#define DMA_ISR_TEIF7_Msk (0x1UL << DMA_ISR_TEIF7_Pos) /*!< 0x08000000 */ +#define DMA_ISR_TEIF7 DMA_ISR_TEIF7_Msk /*!< Channel 7 Transfer Error flag */ + +/******************* Bit definition for DMA_IFCR register *******************/ +#define DMA_IFCR_CGIF1_Pos (0U) +#define DMA_IFCR_CGIF1_Msk (0x1UL << DMA_IFCR_CGIF1_Pos) /*!< 0x00000001 */ +#define DMA_IFCR_CGIF1 DMA_IFCR_CGIF1_Msk /*!< Channel 1 Global interrupt clearr */ +#define DMA_IFCR_CTCIF1_Pos (1U) +#define DMA_IFCR_CTCIF1_Msk (0x1UL << DMA_IFCR_CTCIF1_Pos) /*!< 0x00000002 */ +#define DMA_IFCR_CTCIF1 DMA_IFCR_CTCIF1_Msk /*!< Channel 1 Transfer Complete clear */ +#define DMA_IFCR_CHTIF1_Pos (2U) +#define DMA_IFCR_CHTIF1_Msk (0x1UL << DMA_IFCR_CHTIF1_Pos) /*!< 0x00000004 */ +#define DMA_IFCR_CHTIF1 DMA_IFCR_CHTIF1_Msk /*!< Channel 1 Half Transfer clear */ +#define DMA_IFCR_CTEIF1_Pos (3U) +#define DMA_IFCR_CTEIF1_Msk (0x1UL << DMA_IFCR_CTEIF1_Pos) /*!< 0x00000008 */ +#define DMA_IFCR_CTEIF1 DMA_IFCR_CTEIF1_Msk /*!< Channel 1 Transfer Error clear */ +#define DMA_IFCR_CGIF2_Pos (4U) +#define DMA_IFCR_CGIF2_Msk (0x1UL << DMA_IFCR_CGIF2_Pos) /*!< 0x00000010 */ +#define DMA_IFCR_CGIF2 DMA_IFCR_CGIF2_Msk /*!< Channel 2 Global interrupt clear */ +#define DMA_IFCR_CTCIF2_Pos (5U) +#define DMA_IFCR_CTCIF2_Msk (0x1UL << DMA_IFCR_CTCIF2_Pos) /*!< 0x00000020 */ +#define DMA_IFCR_CTCIF2 DMA_IFCR_CTCIF2_Msk /*!< Channel 2 Transfer Complete clear */ +#define DMA_IFCR_CHTIF2_Pos (6U) +#define DMA_IFCR_CHTIF2_Msk (0x1UL << DMA_IFCR_CHTIF2_Pos) /*!< 0x00000040 */ +#define DMA_IFCR_CHTIF2 DMA_IFCR_CHTIF2_Msk /*!< Channel 2 Half Transfer clear */ +#define DMA_IFCR_CTEIF2_Pos (7U) +#define DMA_IFCR_CTEIF2_Msk (0x1UL << DMA_IFCR_CTEIF2_Pos) /*!< 0x00000080 */ +#define DMA_IFCR_CTEIF2 DMA_IFCR_CTEIF2_Msk /*!< Channel 2 Transfer Error clear */ +#define DMA_IFCR_CGIF3_Pos (8U) +#define DMA_IFCR_CGIF3_Msk (0x1UL << DMA_IFCR_CGIF3_Pos) /*!< 0x00000100 */ +#define DMA_IFCR_CGIF3 DMA_IFCR_CGIF3_Msk /*!< Channel 3 Global interrupt clear */ +#define DMA_IFCR_CTCIF3_Pos (9U) +#define DMA_IFCR_CTCIF3_Msk (0x1UL << DMA_IFCR_CTCIF3_Pos) /*!< 0x00000200 */ +#define DMA_IFCR_CTCIF3 DMA_IFCR_CTCIF3_Msk /*!< Channel 3 Transfer Complete clear */ +#define DMA_IFCR_CHTIF3_Pos (10U) +#define DMA_IFCR_CHTIF3_Msk (0x1UL << DMA_IFCR_CHTIF3_Pos) /*!< 0x00000400 */ +#define DMA_IFCR_CHTIF3 DMA_IFCR_CHTIF3_Msk /*!< Channel 3 Half Transfer clear */ +#define DMA_IFCR_CTEIF3_Pos (11U) +#define DMA_IFCR_CTEIF3_Msk (0x1UL << DMA_IFCR_CTEIF3_Pos) /*!< 0x00000800 */ +#define DMA_IFCR_CTEIF3 DMA_IFCR_CTEIF3_Msk /*!< Channel 3 Transfer Error clear */ +#define DMA_IFCR_CGIF4_Pos (12U) +#define DMA_IFCR_CGIF4_Msk (0x1UL << DMA_IFCR_CGIF4_Pos) /*!< 0x00001000 */ +#define DMA_IFCR_CGIF4 DMA_IFCR_CGIF4_Msk /*!< Channel 4 Global interrupt clear */ +#define DMA_IFCR_CTCIF4_Pos (13U) +#define DMA_IFCR_CTCIF4_Msk (0x1UL << DMA_IFCR_CTCIF4_Pos) /*!< 0x00002000 */ +#define DMA_IFCR_CTCIF4 DMA_IFCR_CTCIF4_Msk /*!< Channel 4 Transfer Complete clear */ +#define DMA_IFCR_CHTIF4_Pos (14U) +#define DMA_IFCR_CHTIF4_Msk (0x1UL << DMA_IFCR_CHTIF4_Pos) /*!< 0x00004000 */ +#define DMA_IFCR_CHTIF4 DMA_IFCR_CHTIF4_Msk /*!< Channel 4 Half Transfer clear */ +#define DMA_IFCR_CTEIF4_Pos (15U) +#define DMA_IFCR_CTEIF4_Msk (0x1UL << DMA_IFCR_CTEIF4_Pos) /*!< 0x00008000 */ +#define DMA_IFCR_CTEIF4 DMA_IFCR_CTEIF4_Msk /*!< Channel 4 Transfer Error clear */ +#define DMA_IFCR_CGIF5_Pos (16U) +#define DMA_IFCR_CGIF5_Msk (0x1UL << DMA_IFCR_CGIF5_Pos) /*!< 0x00010000 */ +#define DMA_IFCR_CGIF5 DMA_IFCR_CGIF5_Msk /*!< Channel 5 Global interrupt clear */ +#define DMA_IFCR_CTCIF5_Pos (17U) +#define DMA_IFCR_CTCIF5_Msk (0x1UL << DMA_IFCR_CTCIF5_Pos) /*!< 0x00020000 */ +#define DMA_IFCR_CTCIF5 DMA_IFCR_CTCIF5_Msk /*!< Channel 5 Transfer Complete clear */ +#define DMA_IFCR_CHTIF5_Pos (18U) +#define DMA_IFCR_CHTIF5_Msk (0x1UL << DMA_IFCR_CHTIF5_Pos) /*!< 0x00040000 */ +#define DMA_IFCR_CHTIF5 DMA_IFCR_CHTIF5_Msk /*!< Channel 5 Half Transfer clear */ +#define DMA_IFCR_CTEIF5_Pos (19U) +#define DMA_IFCR_CTEIF5_Msk (0x1UL << DMA_IFCR_CTEIF5_Pos) /*!< 0x00080000 */ +#define DMA_IFCR_CTEIF5 DMA_IFCR_CTEIF5_Msk /*!< Channel 5 Transfer Error clear */ +#define DMA_IFCR_CGIF6_Pos (20U) +#define DMA_IFCR_CGIF6_Msk (0x1UL << DMA_IFCR_CGIF6_Pos) /*!< 0x00100000 */ +#define DMA_IFCR_CGIF6 DMA_IFCR_CGIF6_Msk /*!< Channel 6 Global interrupt clear */ +#define DMA_IFCR_CTCIF6_Pos (21U) +#define DMA_IFCR_CTCIF6_Msk (0x1UL << DMA_IFCR_CTCIF6_Pos) /*!< 0x00200000 */ +#define DMA_IFCR_CTCIF6 DMA_IFCR_CTCIF6_Msk /*!< Channel 6 Transfer Complete clear */ +#define DMA_IFCR_CHTIF6_Pos (22U) +#define DMA_IFCR_CHTIF6_Msk (0x1UL << DMA_IFCR_CHTIF6_Pos) /*!< 0x00400000 */ +#define DMA_IFCR_CHTIF6 DMA_IFCR_CHTIF6_Msk /*!< Channel 6 Half Transfer clear */ +#define DMA_IFCR_CTEIF6_Pos (23U) +#define DMA_IFCR_CTEIF6_Msk (0x1UL << DMA_IFCR_CTEIF6_Pos) /*!< 0x00800000 */ +#define DMA_IFCR_CTEIF6 DMA_IFCR_CTEIF6_Msk /*!< Channel 6 Transfer Error clear */ +#define DMA_IFCR_CGIF7_Pos (24U) +#define DMA_IFCR_CGIF7_Msk (0x1UL << DMA_IFCR_CGIF7_Pos) /*!< 0x01000000 */ +#define DMA_IFCR_CGIF7 DMA_IFCR_CGIF7_Msk /*!< Channel 7 Global interrupt clear */ +#define DMA_IFCR_CTCIF7_Pos (25U) +#define DMA_IFCR_CTCIF7_Msk (0x1UL << DMA_IFCR_CTCIF7_Pos) /*!< 0x02000000 */ +#define DMA_IFCR_CTCIF7 DMA_IFCR_CTCIF7_Msk /*!< Channel 7 Transfer Complete clear */ +#define DMA_IFCR_CHTIF7_Pos (26U) +#define DMA_IFCR_CHTIF7_Msk (0x1UL << DMA_IFCR_CHTIF7_Pos) /*!< 0x04000000 */ +#define DMA_IFCR_CHTIF7 DMA_IFCR_CHTIF7_Msk /*!< Channel 7 Half Transfer clear */ +#define DMA_IFCR_CTEIF7_Pos (27U) +#define DMA_IFCR_CTEIF7_Msk (0x1UL << DMA_IFCR_CTEIF7_Pos) /*!< 0x08000000 */ +#define DMA_IFCR_CTEIF7 DMA_IFCR_CTEIF7_Msk /*!< Channel 7 Transfer Error clear */ + +/******************* Bit definition for DMA_CCR register ********************/ +#define DMA_CCR_EN_Pos (0U) +#define DMA_CCR_EN_Msk (0x1UL << DMA_CCR_EN_Pos) /*!< 0x00000001 */ +#define DMA_CCR_EN DMA_CCR_EN_Msk /*!< Channel enable */ +#define DMA_CCR_TCIE_Pos (1U) +#define DMA_CCR_TCIE_Msk (0x1UL << DMA_CCR_TCIE_Pos) /*!< 0x00000002 */ +#define DMA_CCR_TCIE DMA_CCR_TCIE_Msk /*!< Transfer complete interrupt enable */ +#define DMA_CCR_HTIE_Pos (2U) +#define DMA_CCR_HTIE_Msk (0x1UL << DMA_CCR_HTIE_Pos) /*!< 0x00000004 */ +#define DMA_CCR_HTIE DMA_CCR_HTIE_Msk /*!< Half Transfer interrupt enable */ +#define DMA_CCR_TEIE_Pos (3U) +#define DMA_CCR_TEIE_Msk (0x1UL << DMA_CCR_TEIE_Pos) /*!< 0x00000008 */ +#define DMA_CCR_TEIE DMA_CCR_TEIE_Msk /*!< Transfer error interrupt enable */ +#define DMA_CCR_DIR_Pos (4U) +#define DMA_CCR_DIR_Msk (0x1UL << DMA_CCR_DIR_Pos) /*!< 0x00000010 */ +#define DMA_CCR_DIR DMA_CCR_DIR_Msk /*!< Data transfer direction */ +#define DMA_CCR_CIRC_Pos (5U) +#define DMA_CCR_CIRC_Msk (0x1UL << DMA_CCR_CIRC_Pos) /*!< 0x00000020 */ +#define DMA_CCR_CIRC DMA_CCR_CIRC_Msk /*!< Circular mode */ +#define DMA_CCR_PINC_Pos (6U) +#define DMA_CCR_PINC_Msk (0x1UL << DMA_CCR_PINC_Pos) /*!< 0x00000040 */ +#define DMA_CCR_PINC DMA_CCR_PINC_Msk /*!< Peripheral increment mode */ +#define DMA_CCR_MINC_Pos (7U) +#define DMA_CCR_MINC_Msk (0x1UL << DMA_CCR_MINC_Pos) /*!< 0x00000080 */ +#define DMA_CCR_MINC DMA_CCR_MINC_Msk /*!< Memory increment mode */ + +#define DMA_CCR_PSIZE_Pos (8U) +#define DMA_CCR_PSIZE_Msk (0x3UL << DMA_CCR_PSIZE_Pos) /*!< 0x00000300 */ +#define DMA_CCR_PSIZE DMA_CCR_PSIZE_Msk /*!< PSIZE[1:0] bits (Peripheral size) */ +#define DMA_CCR_PSIZE_0 (0x1UL << DMA_CCR_PSIZE_Pos) /*!< 0x00000100 */ +#define DMA_CCR_PSIZE_1 (0x2UL << DMA_CCR_PSIZE_Pos) /*!< 0x00000200 */ + +#define DMA_CCR_MSIZE_Pos (10U) +#define DMA_CCR_MSIZE_Msk (0x3UL << DMA_CCR_MSIZE_Pos) /*!< 0x00000C00 */ +#define DMA_CCR_MSIZE DMA_CCR_MSIZE_Msk /*!< MSIZE[1:0] bits (Memory size) */ +#define DMA_CCR_MSIZE_0 (0x1UL << DMA_CCR_MSIZE_Pos) /*!< 0x00000400 */ +#define DMA_CCR_MSIZE_1 (0x2UL << DMA_CCR_MSIZE_Pos) /*!< 0x00000800 */ + +#define DMA_CCR_PL_Pos (12U) +#define DMA_CCR_PL_Msk (0x3UL << DMA_CCR_PL_Pos) /*!< 0x00003000 */ +#define DMA_CCR_PL DMA_CCR_PL_Msk /*!< PL[1:0] bits(Channel Priority level)*/ +#define DMA_CCR_PL_0 (0x1UL << DMA_CCR_PL_Pos) /*!< 0x00001000 */ +#define DMA_CCR_PL_1 (0x2UL << DMA_CCR_PL_Pos) /*!< 0x00002000 */ + +#define DMA_CCR_MEM2MEM_Pos (14U) +#define DMA_CCR_MEM2MEM_Msk (0x1UL << DMA_CCR_MEM2MEM_Pos) /*!< 0x00004000 */ +#define DMA_CCR_MEM2MEM DMA_CCR_MEM2MEM_Msk /*!< Memory to memory mode */ + +/****************** Bit definition for DMA_CNDTR register *******************/ +#define DMA_CNDTR_NDT_Pos (0U) +#define DMA_CNDTR_NDT_Msk (0xFFFFUL << DMA_CNDTR_NDT_Pos) /*!< 0x0000FFFF */ +#define DMA_CNDTR_NDT DMA_CNDTR_NDT_Msk /*!< Number of data to Transfer */ + +/****************** Bit definition for DMA_CPAR register ********************/ +#define DMA_CPAR_PA_Pos (0U) +#define DMA_CPAR_PA_Msk (0xFFFFFFFFUL << DMA_CPAR_PA_Pos) /*!< 0xFFFFFFFF */ +#define DMA_CPAR_PA DMA_CPAR_PA_Msk /*!< Peripheral Address */ + +/****************** Bit definition for DMA_CMAR register ********************/ +#define DMA_CMAR_MA_Pos (0U) +#define DMA_CMAR_MA_Msk (0xFFFFFFFFUL << DMA_CMAR_MA_Pos) /*!< 0xFFFFFFFF */ +#define DMA_CMAR_MA DMA_CMAR_MA_Msk /*!< Memory Address */ + + +/******************* Bit definition for DMA_CSELR register *******************/ +#define DMA_CSELR_C1S_Pos (0U) +#define DMA_CSELR_C1S_Msk (0xFUL << DMA_CSELR_C1S_Pos) /*!< 0x0000000F */ +#define DMA_CSELR_C1S DMA_CSELR_C1S_Msk /*!< Channel 1 Selection */ +#define DMA_CSELR_C2S_Pos (4U) +#define DMA_CSELR_C2S_Msk (0xFUL << DMA_CSELR_C2S_Pos) /*!< 0x000000F0 */ +#define DMA_CSELR_C2S DMA_CSELR_C2S_Msk /*!< Channel 2 Selection */ +#define DMA_CSELR_C3S_Pos (8U) +#define DMA_CSELR_C3S_Msk (0xFUL << DMA_CSELR_C3S_Pos) /*!< 0x00000F00 */ +#define DMA_CSELR_C3S DMA_CSELR_C3S_Msk /*!< Channel 3 Selection */ +#define DMA_CSELR_C4S_Pos (12U) +#define DMA_CSELR_C4S_Msk (0xFUL << DMA_CSELR_C4S_Pos) /*!< 0x0000F000 */ +#define DMA_CSELR_C4S DMA_CSELR_C4S_Msk /*!< Channel 4 Selection */ +#define DMA_CSELR_C5S_Pos (16U) +#define DMA_CSELR_C5S_Msk (0xFUL << DMA_CSELR_C5S_Pos) /*!< 0x000F0000 */ +#define DMA_CSELR_C5S DMA_CSELR_C5S_Msk /*!< Channel 5 Selection */ +#define DMA_CSELR_C6S_Pos (20U) +#define DMA_CSELR_C6S_Msk (0xFUL << DMA_CSELR_C6S_Pos) /*!< 0x00F00000 */ +#define DMA_CSELR_C6S DMA_CSELR_C6S_Msk /*!< Channel 6 Selection */ +#define DMA_CSELR_C7S_Pos (24U) +#define DMA_CSELR_C7S_Msk (0xFUL << DMA_CSELR_C7S_Pos) /*!< 0x0F000000 */ +#define DMA_CSELR_C7S DMA_CSELR_C7S_Msk /*!< Channel 7 Selection */ + +/******************************************************************************/ +/* */ +/* External Interrupt/Event Controller */ +/* */ +/******************************************************************************/ +/******************* Bit definition for EXTI_IMR1 register ******************/ +#define EXTI_IMR1_IM0_Pos (0U) +#define EXTI_IMR1_IM0_Msk (0x1UL << EXTI_IMR1_IM0_Pos) /*!< 0x00000001 */ +#define EXTI_IMR1_IM0 EXTI_IMR1_IM0_Msk /*!< Interrupt Mask on line 0 */ +#define EXTI_IMR1_IM1_Pos (1U) +#define EXTI_IMR1_IM1_Msk (0x1UL << EXTI_IMR1_IM1_Pos) /*!< 0x00000002 */ +#define EXTI_IMR1_IM1 EXTI_IMR1_IM1_Msk /*!< Interrupt Mask on line 1 */ +#define EXTI_IMR1_IM2_Pos (2U) +#define EXTI_IMR1_IM2_Msk (0x1UL << EXTI_IMR1_IM2_Pos) /*!< 0x00000004 */ +#define EXTI_IMR1_IM2 EXTI_IMR1_IM2_Msk /*!< Interrupt Mask on line 2 */ +#define EXTI_IMR1_IM3_Pos (3U) +#define EXTI_IMR1_IM3_Msk (0x1UL << EXTI_IMR1_IM3_Pos) /*!< 0x00000008 */ +#define EXTI_IMR1_IM3 EXTI_IMR1_IM3_Msk /*!< Interrupt Mask on line 3 */ +#define EXTI_IMR1_IM4_Pos (4U) +#define EXTI_IMR1_IM4_Msk (0x1UL << EXTI_IMR1_IM4_Pos) /*!< 0x00000010 */ +#define EXTI_IMR1_IM4 EXTI_IMR1_IM4_Msk /*!< Interrupt Mask on line 4 */ +#define EXTI_IMR1_IM5_Pos (5U) +#define EXTI_IMR1_IM5_Msk (0x1UL << EXTI_IMR1_IM5_Pos) /*!< 0x00000020 */ +#define EXTI_IMR1_IM5 EXTI_IMR1_IM5_Msk /*!< Interrupt Mask on line 5 */ +#define EXTI_IMR1_IM6_Pos (6U) +#define EXTI_IMR1_IM6_Msk (0x1UL << EXTI_IMR1_IM6_Pos) /*!< 0x00000040 */ +#define EXTI_IMR1_IM6 EXTI_IMR1_IM6_Msk /*!< Interrupt Mask on line 6 */ +#define EXTI_IMR1_IM7_Pos (7U) +#define EXTI_IMR1_IM7_Msk (0x1UL << EXTI_IMR1_IM7_Pos) /*!< 0x00000080 */ +#define EXTI_IMR1_IM7 EXTI_IMR1_IM7_Msk /*!< Interrupt Mask on line 7 */ +#define EXTI_IMR1_IM8_Pos (8U) +#define EXTI_IMR1_IM8_Msk (0x1UL << EXTI_IMR1_IM8_Pos) /*!< 0x00000100 */ +#define EXTI_IMR1_IM8 EXTI_IMR1_IM8_Msk /*!< Interrupt Mask on line 8 */ +#define EXTI_IMR1_IM9_Pos (9U) +#define EXTI_IMR1_IM9_Msk (0x1UL << EXTI_IMR1_IM9_Pos) /*!< 0x00000200 */ +#define EXTI_IMR1_IM9 EXTI_IMR1_IM9_Msk /*!< Interrupt Mask on line 9 */ +#define EXTI_IMR1_IM10_Pos (10U) +#define EXTI_IMR1_IM10_Msk (0x1UL << EXTI_IMR1_IM10_Pos) /*!< 0x00000400 */ +#define EXTI_IMR1_IM10 EXTI_IMR1_IM10_Msk /*!< Interrupt Mask on line 10 */ +#define EXTI_IMR1_IM11_Pos (11U) +#define EXTI_IMR1_IM11_Msk (0x1UL << EXTI_IMR1_IM11_Pos) /*!< 0x00000800 */ +#define EXTI_IMR1_IM11 EXTI_IMR1_IM11_Msk /*!< Interrupt Mask on line 11 */ +#define EXTI_IMR1_IM12_Pos (12U) +#define EXTI_IMR1_IM12_Msk (0x1UL << EXTI_IMR1_IM12_Pos) /*!< 0x00001000 */ +#define EXTI_IMR1_IM12 EXTI_IMR1_IM12_Msk /*!< Interrupt Mask on line 12 */ +#define EXTI_IMR1_IM13_Pos (13U) +#define EXTI_IMR1_IM13_Msk (0x1UL << EXTI_IMR1_IM13_Pos) /*!< 0x00002000 */ +#define EXTI_IMR1_IM13 EXTI_IMR1_IM13_Msk /*!< Interrupt Mask on line 13 */ +#define EXTI_IMR1_IM14_Pos (14U) +#define EXTI_IMR1_IM14_Msk (0x1UL << EXTI_IMR1_IM14_Pos) /*!< 0x00004000 */ +#define EXTI_IMR1_IM14 EXTI_IMR1_IM14_Msk /*!< Interrupt Mask on line 14 */ +#define EXTI_IMR1_IM15_Pos (15U) +#define EXTI_IMR1_IM15_Msk (0x1UL << EXTI_IMR1_IM15_Pos) /*!< 0x00008000 */ +#define EXTI_IMR1_IM15 EXTI_IMR1_IM15_Msk /*!< Interrupt Mask on line 15 */ +#define EXTI_IMR1_IM16_Pos (16U) +#define EXTI_IMR1_IM16_Msk (0x1UL << EXTI_IMR1_IM16_Pos) /*!< 0x00010000 */ +#define EXTI_IMR1_IM16 EXTI_IMR1_IM16_Msk /*!< Interrupt Mask on line 16 */ +#define EXTI_IMR1_IM17_Pos (17U) +#define EXTI_IMR1_IM17_Msk (0x1UL << EXTI_IMR1_IM17_Pos) /*!< 0x00020000 */ +#define EXTI_IMR1_IM17 EXTI_IMR1_IM17_Msk /*!< Interrupt Mask on line 17 */ +#define EXTI_IMR1_IM18_Pos (18U) +#define EXTI_IMR1_IM18_Msk (0x1UL << EXTI_IMR1_IM18_Pos) /*!< 0x00040000 */ +#define EXTI_IMR1_IM18 EXTI_IMR1_IM18_Msk /*!< Interrupt Mask on line 18 */ +#define EXTI_IMR1_IM19_Pos (19U) +#define EXTI_IMR1_IM19_Msk (0x1UL << EXTI_IMR1_IM19_Pos) /*!< 0x00080000 */ +#define EXTI_IMR1_IM19 EXTI_IMR1_IM19_Msk /*!< Interrupt Mask on line 19 */ +#define EXTI_IMR1_IM20_Pos (20U) +#define EXTI_IMR1_IM20_Msk (0x1UL << EXTI_IMR1_IM20_Pos) /*!< 0x00100000 */ +#define EXTI_IMR1_IM20 EXTI_IMR1_IM20_Msk /*!< Interrupt Mask on line 20 */ +#define EXTI_IMR1_IM21_Pos (21U) +#define EXTI_IMR1_IM21_Msk (0x1UL << EXTI_IMR1_IM21_Pos) /*!< 0x00200000 */ +#define EXTI_IMR1_IM21 EXTI_IMR1_IM21_Msk /*!< Interrupt Mask on line 21 */ +#define EXTI_IMR1_IM23_Pos (23U) +#define EXTI_IMR1_IM23_Msk (0x1UL << EXTI_IMR1_IM23_Pos) /*!< 0x00800000 */ +#define EXTI_IMR1_IM23 EXTI_IMR1_IM23_Msk /*!< Interrupt Mask on line 23 */ +#define EXTI_IMR1_IM24_Pos (24U) +#define EXTI_IMR1_IM24_Msk (0x1UL << EXTI_IMR1_IM24_Pos) /*!< 0x01000000 */ +#define EXTI_IMR1_IM24 EXTI_IMR1_IM24_Msk /*!< Interrupt Mask on line 24 */ +#define EXTI_IMR1_IM25_Pos (25U) +#define EXTI_IMR1_IM25_Msk (0x1UL << EXTI_IMR1_IM25_Pos) /*!< 0x02000000 */ +#define EXTI_IMR1_IM25 EXTI_IMR1_IM25_Msk /*!< Interrupt Mask on line 25 */ +#define EXTI_IMR1_IM26_Pos (26U) +#define EXTI_IMR1_IM26_Msk (0x1UL << EXTI_IMR1_IM26_Pos) /*!< 0x04000000 */ +#define EXTI_IMR1_IM26 EXTI_IMR1_IM26_Msk /*!< Interrupt Mask on line 26 */ +#define EXTI_IMR1_IM27_Pos (27U) +#define EXTI_IMR1_IM27_Msk (0x1UL << EXTI_IMR1_IM27_Pos) /*!< 0x08000000 */ +#define EXTI_IMR1_IM27 EXTI_IMR1_IM27_Msk /*!< Interrupt Mask on line 27 */ +#define EXTI_IMR1_IM28_Pos (28U) +#define EXTI_IMR1_IM28_Msk (0x1UL << EXTI_IMR1_IM28_Pos) /*!< 0x10000000 */ +#define EXTI_IMR1_IM28 EXTI_IMR1_IM28_Msk /*!< Interrupt Mask on line 28 */ +#define EXTI_IMR1_IM29_Pos (29U) +#define EXTI_IMR1_IM29_Msk (0x1UL << EXTI_IMR1_IM29_Pos) /*!< 0x20000000 */ +#define EXTI_IMR1_IM29 EXTI_IMR1_IM29_Msk /*!< Interrupt Mask on line 29 */ +#define EXTI_IMR1_IM30_Pos (30U) +#define EXTI_IMR1_IM30_Msk (0x1UL << EXTI_IMR1_IM30_Pos) /*!< 0x40000000 */ +#define EXTI_IMR1_IM30 EXTI_IMR1_IM30_Msk /*!< Interrupt Mask on line 30 */ +#define EXTI_IMR1_IM31_Pos (31U) +#define EXTI_IMR1_IM31_Msk (0x1UL << EXTI_IMR1_IM31_Pos) /*!< 0x80000000 */ +#define EXTI_IMR1_IM31 EXTI_IMR1_IM31_Msk /*!< Interrupt Mask on line 31 */ +#define EXTI_IMR1_IM_Pos (0U) +#define EXTI_IMR1_IM_Msk (0x9FFFFFFFUL << EXTI_IMR1_IM_Pos) /*!< 0x9FFFFFFF */ +#define EXTI_IMR1_IM EXTI_IMR1_IM_Msk /*!< Interrupt Mask All */ + +/******************* Bit definition for EXTI_EMR1 register ******************/ +#define EXTI_EMR1_EM0_Pos (0U) +#define EXTI_EMR1_EM0_Msk (0x1UL << EXTI_EMR1_EM0_Pos) /*!< 0x00000001 */ +#define EXTI_EMR1_EM0 EXTI_EMR1_EM0_Msk /*!< Event Mask on line 0 */ +#define EXTI_EMR1_EM1_Pos (1U) +#define EXTI_EMR1_EM1_Msk (0x1UL << EXTI_EMR1_EM1_Pos) /*!< 0x00000002 */ +#define EXTI_EMR1_EM1 EXTI_EMR1_EM1_Msk /*!< Event Mask on line 1 */ +#define EXTI_EMR1_EM2_Pos (2U) +#define EXTI_EMR1_EM2_Msk (0x1UL << EXTI_EMR1_EM2_Pos) /*!< 0x00000004 */ +#define EXTI_EMR1_EM2 EXTI_EMR1_EM2_Msk /*!< Event Mask on line 2 */ +#define EXTI_EMR1_EM3_Pos (3U) +#define EXTI_EMR1_EM3_Msk (0x1UL << EXTI_EMR1_EM3_Pos) /*!< 0x00000008 */ +#define EXTI_EMR1_EM3 EXTI_EMR1_EM3_Msk /*!< Event Mask on line 3 */ +#define EXTI_EMR1_EM4_Pos (4U) +#define EXTI_EMR1_EM4_Msk (0x1UL << EXTI_EMR1_EM4_Pos) /*!< 0x00000010 */ +#define EXTI_EMR1_EM4 EXTI_EMR1_EM4_Msk /*!< Event Mask on line 4 */ +#define EXTI_EMR1_EM5_Pos (5U) +#define EXTI_EMR1_EM5_Msk (0x1UL << EXTI_EMR1_EM5_Pos) /*!< 0x00000020 */ +#define EXTI_EMR1_EM5 EXTI_EMR1_EM5_Msk /*!< Event Mask on line 5 */ +#define EXTI_EMR1_EM6_Pos (6U) +#define EXTI_EMR1_EM6_Msk (0x1UL << EXTI_EMR1_EM6_Pos) /*!< 0x00000040 */ +#define EXTI_EMR1_EM6 EXTI_EMR1_EM6_Msk /*!< Event Mask on line 6 */ +#define EXTI_EMR1_EM7_Pos (7U) +#define EXTI_EMR1_EM7_Msk (0x1UL << EXTI_EMR1_EM7_Pos) /*!< 0x00000080 */ +#define EXTI_EMR1_EM7 EXTI_EMR1_EM7_Msk /*!< Event Mask on line 7 */ +#define EXTI_EMR1_EM8_Pos (8U) +#define EXTI_EMR1_EM8_Msk (0x1UL << EXTI_EMR1_EM8_Pos) /*!< 0x00000100 */ +#define EXTI_EMR1_EM8 EXTI_EMR1_EM8_Msk /*!< Event Mask on line 8 */ +#define EXTI_EMR1_EM9_Pos (9U) +#define EXTI_EMR1_EM9_Msk (0x1UL << EXTI_EMR1_EM9_Pos) /*!< 0x00000200 */ +#define EXTI_EMR1_EM9 EXTI_EMR1_EM9_Msk /*!< Event Mask on line 9 */ +#define EXTI_EMR1_EM10_Pos (10U) +#define EXTI_EMR1_EM10_Msk (0x1UL << EXTI_EMR1_EM10_Pos) /*!< 0x00000400 */ +#define EXTI_EMR1_EM10 EXTI_EMR1_EM10_Msk /*!< Event Mask on line 10 */ +#define EXTI_EMR1_EM11_Pos (11U) +#define EXTI_EMR1_EM11_Msk (0x1UL << EXTI_EMR1_EM11_Pos) /*!< 0x00000800 */ +#define EXTI_EMR1_EM11 EXTI_EMR1_EM11_Msk /*!< Event Mask on line 11 */ +#define EXTI_EMR1_EM12_Pos (12U) +#define EXTI_EMR1_EM12_Msk (0x1UL << EXTI_EMR1_EM12_Pos) /*!< 0x00001000 */ +#define EXTI_EMR1_EM12 EXTI_EMR1_EM12_Msk /*!< Event Mask on line 12 */ +#define EXTI_EMR1_EM13_Pos (13U) +#define EXTI_EMR1_EM13_Msk (0x1UL << EXTI_EMR1_EM13_Pos) /*!< 0x00002000 */ +#define EXTI_EMR1_EM13 EXTI_EMR1_EM13_Msk /*!< Event Mask on line 13 */ +#define EXTI_EMR1_EM14_Pos (14U) +#define EXTI_EMR1_EM14_Msk (0x1UL << EXTI_EMR1_EM14_Pos) /*!< 0x00004000 */ +#define EXTI_EMR1_EM14 EXTI_EMR1_EM14_Msk /*!< Event Mask on line 14 */ +#define EXTI_EMR1_EM15_Pos (15U) +#define EXTI_EMR1_EM15_Msk (0x1UL << EXTI_EMR1_EM15_Pos) /*!< 0x00008000 */ +#define EXTI_EMR1_EM15 EXTI_EMR1_EM15_Msk /*!< Event Mask on line 15 */ +#define EXTI_EMR1_EM16_Pos (16U) +#define EXTI_EMR1_EM16_Msk (0x1UL << EXTI_EMR1_EM16_Pos) /*!< 0x00010000 */ +#define EXTI_EMR1_EM16 EXTI_EMR1_EM16_Msk /*!< Event Mask on line 16 */ +#define EXTI_EMR1_EM17_Pos (17U) +#define EXTI_EMR1_EM17_Msk (0x1UL << EXTI_EMR1_EM17_Pos) /*!< 0x00020000 */ +#define EXTI_EMR1_EM17 EXTI_EMR1_EM17_Msk /*!< Event Mask on line 17 */ +#define EXTI_EMR1_EM18_Pos (18U) +#define EXTI_EMR1_EM18_Msk (0x1UL << EXTI_EMR1_EM18_Pos) /*!< 0x00040000 */ +#define EXTI_EMR1_EM18 EXTI_EMR1_EM18_Msk /*!< Event Mask on line 18 */ +#define EXTI_EMR1_EM19_Pos (19U) +#define EXTI_EMR1_EM19_Msk (0x1UL << EXTI_EMR1_EM19_Pos) /*!< 0x00080000 */ +#define EXTI_EMR1_EM19 EXTI_EMR1_EM19_Msk /*!< Event Mask on line 19 */ +#define EXTI_EMR1_EM20_Pos (20U) +#define EXTI_EMR1_EM20_Msk (0x1UL << EXTI_EMR1_EM20_Pos) /*!< 0x00100000 */ +#define EXTI_EMR1_EM20 EXTI_EMR1_EM20_Msk /*!< Event Mask on line 20 */ +#define EXTI_EMR1_EM21_Pos (21U) +#define EXTI_EMR1_EM21_Msk (0x1UL << EXTI_EMR1_EM21_Pos) /*!< 0x00200000 */ +#define EXTI_EMR1_EM21 EXTI_EMR1_EM21_Msk /*!< Event Mask on line 21 */ +#define EXTI_EMR1_EM23_Pos (23U) +#define EXTI_EMR1_EM23_Msk (0x1UL << EXTI_EMR1_EM23_Pos) /*!< 0x00800000 */ +#define EXTI_EMR1_EM23 EXTI_EMR1_EM23_Msk /*!< Event Mask on line 23 */ +#define EXTI_EMR1_EM24_Pos (24U) +#define EXTI_EMR1_EM24_Msk (0x1UL << EXTI_EMR1_EM24_Pos) /*!< 0x01000000 */ +#define EXTI_EMR1_EM24 EXTI_EMR1_EM24_Msk /*!< Event Mask on line 24 */ +#define EXTI_EMR1_EM25_Pos (25U) +#define EXTI_EMR1_EM25_Msk (0x1UL << EXTI_EMR1_EM25_Pos) /*!< 0x02000000 */ +#define EXTI_EMR1_EM25 EXTI_EMR1_EM25_Msk /*!< Event Mask on line 25 */ +#define EXTI_EMR1_EM26_Pos (26U) +#define EXTI_EMR1_EM26_Msk (0x1UL << EXTI_EMR1_EM26_Pos) /*!< 0x04000000 */ +#define EXTI_EMR1_EM26 EXTI_EMR1_EM26_Msk /*!< Event Mask on line 26 */ +#define EXTI_EMR1_EM27_Pos (27U) +#define EXTI_EMR1_EM27_Msk (0x1UL << EXTI_EMR1_EM27_Pos) /*!< 0x08000000 */ +#define EXTI_EMR1_EM27 EXTI_EMR1_EM27_Msk /*!< Event Mask on line 27 */ +#define EXTI_EMR1_EM28_Pos (28U) +#define EXTI_EMR1_EM28_Msk (0x1UL << EXTI_EMR1_EM28_Pos) /*!< 0x10000000 */ +#define EXTI_EMR1_EM28 EXTI_EMR1_EM28_Msk /*!< Event Mask on line 28 */ +#define EXTI_EMR1_EM31_Pos (31U) +#define EXTI_EMR1_EM31_Msk (0x1UL << EXTI_EMR1_EM31_Pos) /*!< 0x80000000 */ +#define EXTI_EMR1_EM31 EXTI_EMR1_EM31_Msk /*!< Event Mask on line 31 */ + +/****************** Bit definition for EXTI_RTSR1 register ******************/ +#define EXTI_RTSR1_RT0_Pos (0U) +#define EXTI_RTSR1_RT0_Msk (0x1UL << EXTI_RTSR1_RT0_Pos) /*!< 0x00000001 */ +#define EXTI_RTSR1_RT0 EXTI_RTSR1_RT0_Msk /*!< Rising trigger event configuration bit of line 0 */ +#define EXTI_RTSR1_RT1_Pos (1U) +#define EXTI_RTSR1_RT1_Msk (0x1UL << EXTI_RTSR1_RT1_Pos) /*!< 0x00000002 */ +#define EXTI_RTSR1_RT1 EXTI_RTSR1_RT1_Msk /*!< Rising trigger event configuration bit of line 1 */ +#define EXTI_RTSR1_RT2_Pos (2U) +#define EXTI_RTSR1_RT2_Msk (0x1UL << EXTI_RTSR1_RT2_Pos) /*!< 0x00000004 */ +#define EXTI_RTSR1_RT2 EXTI_RTSR1_RT2_Msk /*!< Rising trigger event configuration bit of line 2 */ +#define EXTI_RTSR1_RT3_Pos (3U) +#define EXTI_RTSR1_RT3_Msk (0x1UL << EXTI_RTSR1_RT3_Pos) /*!< 0x00000008 */ +#define EXTI_RTSR1_RT3 EXTI_RTSR1_RT3_Msk /*!< Rising trigger event configuration bit of line 3 */ +#define EXTI_RTSR1_RT4_Pos (4U) +#define EXTI_RTSR1_RT4_Msk (0x1UL << EXTI_RTSR1_RT4_Pos) /*!< 0x00000010 */ +#define EXTI_RTSR1_RT4 EXTI_RTSR1_RT4_Msk /*!< Rising trigger event configuration bit of line 4 */ +#define EXTI_RTSR1_RT5_Pos (5U) +#define EXTI_RTSR1_RT5_Msk (0x1UL << EXTI_RTSR1_RT5_Pos) /*!< 0x00000020 */ +#define EXTI_RTSR1_RT5 EXTI_RTSR1_RT5_Msk /*!< Rising trigger event configuration bit of line 5 */ +#define EXTI_RTSR1_RT6_Pos (6U) +#define EXTI_RTSR1_RT6_Msk (0x1UL << EXTI_RTSR1_RT6_Pos) /*!< 0x00000040 */ +#define EXTI_RTSR1_RT6 EXTI_RTSR1_RT6_Msk /*!< Rising trigger event configuration bit of line 6 */ +#define EXTI_RTSR1_RT7_Pos (7U) +#define EXTI_RTSR1_RT7_Msk (0x1UL << EXTI_RTSR1_RT7_Pos) /*!< 0x00000080 */ +#define EXTI_RTSR1_RT7 EXTI_RTSR1_RT7_Msk /*!< Rising trigger event configuration bit of line 7 */ +#define EXTI_RTSR1_RT8_Pos (8U) +#define EXTI_RTSR1_RT8_Msk (0x1UL << EXTI_RTSR1_RT8_Pos) /*!< 0x00000100 */ +#define EXTI_RTSR1_RT8 EXTI_RTSR1_RT8_Msk /*!< Rising trigger event configuration bit of line 8 */ +#define EXTI_RTSR1_RT9_Pos (9U) +#define EXTI_RTSR1_RT9_Msk (0x1UL << EXTI_RTSR1_RT9_Pos) /*!< 0x00000200 */ +#define EXTI_RTSR1_RT9 EXTI_RTSR1_RT9_Msk /*!< Rising trigger event configuration bit of line 9 */ +#define EXTI_RTSR1_RT10_Pos (10U) +#define EXTI_RTSR1_RT10_Msk (0x1UL << EXTI_RTSR1_RT10_Pos) /*!< 0x00000400 */ +#define EXTI_RTSR1_RT10 EXTI_RTSR1_RT10_Msk /*!< Rising trigger event configuration bit of line 10 */ +#define EXTI_RTSR1_RT11_Pos (11U) +#define EXTI_RTSR1_RT11_Msk (0x1UL << EXTI_RTSR1_RT11_Pos) /*!< 0x00000800 */ +#define EXTI_RTSR1_RT11 EXTI_RTSR1_RT11_Msk /*!< Rising trigger event configuration bit of line 11 */ +#define EXTI_RTSR1_RT12_Pos (12U) +#define EXTI_RTSR1_RT12_Msk (0x1UL << EXTI_RTSR1_RT12_Pos) /*!< 0x00001000 */ +#define EXTI_RTSR1_RT12 EXTI_RTSR1_RT12_Msk /*!< Rising trigger event configuration bit of line 12 */ +#define EXTI_RTSR1_RT13_Pos (13U) +#define EXTI_RTSR1_RT13_Msk (0x1UL << EXTI_RTSR1_RT13_Pos) /*!< 0x00002000 */ +#define EXTI_RTSR1_RT13 EXTI_RTSR1_RT13_Msk /*!< Rising trigger event configuration bit of line 13 */ +#define EXTI_RTSR1_RT14_Pos (14U) +#define EXTI_RTSR1_RT14_Msk (0x1UL << EXTI_RTSR1_RT14_Pos) /*!< 0x00004000 */ +#define EXTI_RTSR1_RT14 EXTI_RTSR1_RT14_Msk /*!< Rising trigger event configuration bit of line 14 */ +#define EXTI_RTSR1_RT15_Pos (15U) +#define EXTI_RTSR1_RT15_Msk (0x1UL << EXTI_RTSR1_RT15_Pos) /*!< 0x00008000 */ +#define EXTI_RTSR1_RT15 EXTI_RTSR1_RT15_Msk /*!< Rising trigger event configuration bit of line 15 */ +#define EXTI_RTSR1_RT16_Pos (16U) +#define EXTI_RTSR1_RT16_Msk (0x1UL << EXTI_RTSR1_RT16_Pos) /*!< 0x00010000 */ +#define EXTI_RTSR1_RT16 EXTI_RTSR1_RT16_Msk /*!< Rising trigger event configuration bit of line 16 */ +#define EXTI_RTSR1_RT18_Pos (18U) +#define EXTI_RTSR1_RT18_Msk (0x1UL << EXTI_RTSR1_RT18_Pos) /*!< 0x00040000 */ +#define EXTI_RTSR1_RT18 EXTI_RTSR1_RT18_Msk /*!< Rising trigger event configuration bit of line 18 */ +#define EXTI_RTSR1_RT19_Pos (19U) +#define EXTI_RTSR1_RT19_Msk (0x1UL << EXTI_RTSR1_RT19_Pos) /*!< 0x00080000 */ +#define EXTI_RTSR1_RT19 EXTI_RTSR1_RT19_Msk /*!< Rising trigger event configuration bit of line 19 */ +#define EXTI_RTSR1_RT20_Pos (20U) +#define EXTI_RTSR1_RT20_Msk (0x1UL << EXTI_RTSR1_RT20_Pos) /*!< 0x00100000 */ +#define EXTI_RTSR1_RT20 EXTI_RTSR1_RT20_Msk /*!< Rising trigger event configuration bit of line 20 */ +#define EXTI_RTSR1_RT21_Pos (21U) +#define EXTI_RTSR1_RT21_Msk (0x1UL << EXTI_RTSR1_RT21_Pos) /*!< 0x00200000 */ +#define EXTI_RTSR1_RT21 EXTI_RTSR1_RT21_Msk /*!< Rising trigger event configuration bit of line 21 */ + +/****************** Bit definition for EXTI_FTSR1 register ******************/ +#define EXTI_FTSR1_FT0_Pos (0U) +#define EXTI_FTSR1_FT0_Msk (0x1UL << EXTI_FTSR1_FT0_Pos) /*!< 0x00000001 */ +#define EXTI_FTSR1_FT0 EXTI_FTSR1_FT0_Msk /*!< Falling trigger event configuration bit of line 0 */ +#define EXTI_FTSR1_FT1_Pos (1U) +#define EXTI_FTSR1_FT1_Msk (0x1UL << EXTI_FTSR1_FT1_Pos) /*!< 0x00000002 */ +#define EXTI_FTSR1_FT1 EXTI_FTSR1_FT1_Msk /*!< Falling trigger event configuration bit of line 1 */ +#define EXTI_FTSR1_FT2_Pos (2U) +#define EXTI_FTSR1_FT2_Msk (0x1UL << EXTI_FTSR1_FT2_Pos) /*!< 0x00000004 */ +#define EXTI_FTSR1_FT2 EXTI_FTSR1_FT2_Msk /*!< Falling trigger event configuration bit of line 2 */ +#define EXTI_FTSR1_FT3_Pos (3U) +#define EXTI_FTSR1_FT3_Msk (0x1UL << EXTI_FTSR1_FT3_Pos) /*!< 0x00000008 */ +#define EXTI_FTSR1_FT3 EXTI_FTSR1_FT3_Msk /*!< Falling trigger event configuration bit of line 3 */ +#define EXTI_FTSR1_FT4_Pos (4U) +#define EXTI_FTSR1_FT4_Msk (0x1UL << EXTI_FTSR1_FT4_Pos) /*!< 0x00000010 */ +#define EXTI_FTSR1_FT4 EXTI_FTSR1_FT4_Msk /*!< Falling trigger event configuration bit of line 4 */ +#define EXTI_FTSR1_FT5_Pos (5U) +#define EXTI_FTSR1_FT5_Msk (0x1UL << EXTI_FTSR1_FT5_Pos) /*!< 0x00000020 */ +#define EXTI_FTSR1_FT5 EXTI_FTSR1_FT5_Msk /*!< Falling trigger event configuration bit of line 5 */ +#define EXTI_FTSR1_FT6_Pos (6U) +#define EXTI_FTSR1_FT6_Msk (0x1UL << EXTI_FTSR1_FT6_Pos) /*!< 0x00000040 */ +#define EXTI_FTSR1_FT6 EXTI_FTSR1_FT6_Msk /*!< Falling trigger event configuration bit of line 6 */ +#define EXTI_FTSR1_FT7_Pos (7U) +#define EXTI_FTSR1_FT7_Msk (0x1UL << EXTI_FTSR1_FT7_Pos) /*!< 0x00000080 */ +#define EXTI_FTSR1_FT7 EXTI_FTSR1_FT7_Msk /*!< Falling trigger event configuration bit of line 7 */ +#define EXTI_FTSR1_FT8_Pos (8U) +#define EXTI_FTSR1_FT8_Msk (0x1UL << EXTI_FTSR1_FT8_Pos) /*!< 0x00000100 */ +#define EXTI_FTSR1_FT8 EXTI_FTSR1_FT8_Msk /*!< Falling trigger event configuration bit of line 8 */ +#define EXTI_FTSR1_FT9_Pos (9U) +#define EXTI_FTSR1_FT9_Msk (0x1UL << EXTI_FTSR1_FT9_Pos) /*!< 0x00000200 */ +#define EXTI_FTSR1_FT9 EXTI_FTSR1_FT9_Msk /*!< Falling trigger event configuration bit of line 9 */ +#define EXTI_FTSR1_FT10_Pos (10U) +#define EXTI_FTSR1_FT10_Msk (0x1UL << EXTI_FTSR1_FT10_Pos) /*!< 0x00000400 */ +#define EXTI_FTSR1_FT10 EXTI_FTSR1_FT10_Msk /*!< Falling trigger event configuration bit of line 10 */ +#define EXTI_FTSR1_FT11_Pos (11U) +#define EXTI_FTSR1_FT11_Msk (0x1UL << EXTI_FTSR1_FT11_Pos) /*!< 0x00000800 */ +#define EXTI_FTSR1_FT11 EXTI_FTSR1_FT11_Msk /*!< Falling trigger event configuration bit of line 11 */ +#define EXTI_FTSR1_FT12_Pos (12U) +#define EXTI_FTSR1_FT12_Msk (0x1UL << EXTI_FTSR1_FT12_Pos) /*!< 0x00001000 */ +#define EXTI_FTSR1_FT12 EXTI_FTSR1_FT12_Msk /*!< Falling trigger event configuration bit of line 12 */ +#define EXTI_FTSR1_FT13_Pos (13U) +#define EXTI_FTSR1_FT13_Msk (0x1UL << EXTI_FTSR1_FT13_Pos) /*!< 0x00002000 */ +#define EXTI_FTSR1_FT13 EXTI_FTSR1_FT13_Msk /*!< Falling trigger event configuration bit of line 13 */ +#define EXTI_FTSR1_FT14_Pos (14U) +#define EXTI_FTSR1_FT14_Msk (0x1UL << EXTI_FTSR1_FT14_Pos) /*!< 0x00004000 */ +#define EXTI_FTSR1_FT14 EXTI_FTSR1_FT14_Msk /*!< Falling trigger event configuration bit of line 14 */ +#define EXTI_FTSR1_FT15_Pos (15U) +#define EXTI_FTSR1_FT15_Msk (0x1UL << EXTI_FTSR1_FT15_Pos) /*!< 0x00008000 */ +#define EXTI_FTSR1_FT15 EXTI_FTSR1_FT15_Msk /*!< Falling trigger event configuration bit of line 15 */ +#define EXTI_FTSR1_FT16_Pos (16U) +#define EXTI_FTSR1_FT16_Msk (0x1UL << EXTI_FTSR1_FT16_Pos) /*!< 0x00010000 */ +#define EXTI_FTSR1_FT16 EXTI_FTSR1_FT16_Msk /*!< Falling trigger event configuration bit of line 16 */ +#define EXTI_FTSR1_FT18_Pos (18U) +#define EXTI_FTSR1_FT18_Msk (0x1UL << EXTI_FTSR1_FT18_Pos) /*!< 0x00040000 */ +#define EXTI_FTSR1_FT18 EXTI_FTSR1_FT18_Msk /*!< Falling trigger event configuration bit of line 18 */ +#define EXTI_FTSR1_FT19_Pos (19U) +#define EXTI_FTSR1_FT19_Msk (0x1UL << EXTI_FTSR1_FT19_Pos) /*!< 0x00080000 */ +#define EXTI_FTSR1_FT19 EXTI_FTSR1_FT19_Msk /*!< Falling trigger event configuration bit of line 19 */ +#define EXTI_FTSR1_FT20_Pos (20U) +#define EXTI_FTSR1_FT20_Msk (0x1UL << EXTI_FTSR1_FT20_Pos) /*!< 0x00100000 */ +#define EXTI_FTSR1_FT20 EXTI_FTSR1_FT20_Msk /*!< Falling trigger event configuration bit of line 20 */ +#define EXTI_FTSR1_FT21_Pos (21U) +#define EXTI_FTSR1_FT21_Msk (0x1UL << EXTI_FTSR1_FT21_Pos) /*!< 0x00200000 */ +#define EXTI_FTSR1_FT21 EXTI_FTSR1_FT21_Msk /*!< Falling trigger event configuration bit of line 21 */ + +/****************** Bit definition for EXTI_SWIER1 register *****************/ +#define EXTI_SWIER1_SWI0_Pos (0U) +#define EXTI_SWIER1_SWI0_Msk (0x1UL << EXTI_SWIER1_SWI0_Pos) /*!< 0x00000001 */ +#define EXTI_SWIER1_SWI0 EXTI_SWIER1_SWI0_Msk /*!< Software Interrupt on line 0 */ +#define EXTI_SWIER1_SWI1_Pos (1U) +#define EXTI_SWIER1_SWI1_Msk (0x1UL << EXTI_SWIER1_SWI1_Pos) /*!< 0x00000002 */ +#define EXTI_SWIER1_SWI1 EXTI_SWIER1_SWI1_Msk /*!< Software Interrupt on line 1 */ +#define EXTI_SWIER1_SWI2_Pos (2U) +#define EXTI_SWIER1_SWI2_Msk (0x1UL << EXTI_SWIER1_SWI2_Pos) /*!< 0x00000004 */ +#define EXTI_SWIER1_SWI2 EXTI_SWIER1_SWI2_Msk /*!< Software Interrupt on line 2 */ +#define EXTI_SWIER1_SWI3_Pos (3U) +#define EXTI_SWIER1_SWI3_Msk (0x1UL << EXTI_SWIER1_SWI3_Pos) /*!< 0x00000008 */ +#define EXTI_SWIER1_SWI3 EXTI_SWIER1_SWI3_Msk /*!< Software Interrupt on line 3 */ +#define EXTI_SWIER1_SWI4_Pos (4U) +#define EXTI_SWIER1_SWI4_Msk (0x1UL << EXTI_SWIER1_SWI4_Pos) /*!< 0x00000010 */ +#define EXTI_SWIER1_SWI4 EXTI_SWIER1_SWI4_Msk /*!< Software Interrupt on line 4 */ +#define EXTI_SWIER1_SWI5_Pos (5U) +#define EXTI_SWIER1_SWI5_Msk (0x1UL << EXTI_SWIER1_SWI5_Pos) /*!< 0x00000020 */ +#define EXTI_SWIER1_SWI5 EXTI_SWIER1_SWI5_Msk /*!< Software Interrupt on line 5 */ +#define EXTI_SWIER1_SWI6_Pos (6U) +#define EXTI_SWIER1_SWI6_Msk (0x1UL << EXTI_SWIER1_SWI6_Pos) /*!< 0x00000040 */ +#define EXTI_SWIER1_SWI6 EXTI_SWIER1_SWI6_Msk /*!< Software Interrupt on line 6 */ +#define EXTI_SWIER1_SWI7_Pos (7U) +#define EXTI_SWIER1_SWI7_Msk (0x1UL << EXTI_SWIER1_SWI7_Pos) /*!< 0x00000080 */ +#define EXTI_SWIER1_SWI7 EXTI_SWIER1_SWI7_Msk /*!< Software Interrupt on line 7 */ +#define EXTI_SWIER1_SWI8_Pos (8U) +#define EXTI_SWIER1_SWI8_Msk (0x1UL << EXTI_SWIER1_SWI8_Pos) /*!< 0x00000100 */ +#define EXTI_SWIER1_SWI8 EXTI_SWIER1_SWI8_Msk /*!< Software Interrupt on line 8 */ +#define EXTI_SWIER1_SWI9_Pos (9U) +#define EXTI_SWIER1_SWI9_Msk (0x1UL << EXTI_SWIER1_SWI9_Pos) /*!< 0x00000200 */ +#define EXTI_SWIER1_SWI9 EXTI_SWIER1_SWI9_Msk /*!< Software Interrupt on line 9 */ +#define EXTI_SWIER1_SWI10_Pos (10U) +#define EXTI_SWIER1_SWI10_Msk (0x1UL << EXTI_SWIER1_SWI10_Pos) /*!< 0x00000400 */ +#define EXTI_SWIER1_SWI10 EXTI_SWIER1_SWI10_Msk /*!< Software Interrupt on line 10 */ +#define EXTI_SWIER1_SWI11_Pos (11U) +#define EXTI_SWIER1_SWI11_Msk (0x1UL << EXTI_SWIER1_SWI11_Pos) /*!< 0x00000800 */ +#define EXTI_SWIER1_SWI11 EXTI_SWIER1_SWI11_Msk /*!< Software Interrupt on line 11 */ +#define EXTI_SWIER1_SWI12_Pos (12U) +#define EXTI_SWIER1_SWI12_Msk (0x1UL << EXTI_SWIER1_SWI12_Pos) /*!< 0x00001000 */ +#define EXTI_SWIER1_SWI12 EXTI_SWIER1_SWI12_Msk /*!< Software Interrupt on line 12 */ +#define EXTI_SWIER1_SWI13_Pos (13U) +#define EXTI_SWIER1_SWI13_Msk (0x1UL << EXTI_SWIER1_SWI13_Pos) /*!< 0x00002000 */ +#define EXTI_SWIER1_SWI13 EXTI_SWIER1_SWI13_Msk /*!< Software Interrupt on line 13 */ +#define EXTI_SWIER1_SWI14_Pos (14U) +#define EXTI_SWIER1_SWI14_Msk (0x1UL << EXTI_SWIER1_SWI14_Pos) /*!< 0x00004000 */ +#define EXTI_SWIER1_SWI14 EXTI_SWIER1_SWI14_Msk /*!< Software Interrupt on line 14 */ +#define EXTI_SWIER1_SWI15_Pos (15U) +#define EXTI_SWIER1_SWI15_Msk (0x1UL << EXTI_SWIER1_SWI15_Pos) /*!< 0x00008000 */ +#define EXTI_SWIER1_SWI15 EXTI_SWIER1_SWI15_Msk /*!< Software Interrupt on line 15 */ +#define EXTI_SWIER1_SWI16_Pos (16U) +#define EXTI_SWIER1_SWI16_Msk (0x1UL << EXTI_SWIER1_SWI16_Pos) /*!< 0x00010000 */ +#define EXTI_SWIER1_SWI16 EXTI_SWIER1_SWI16_Msk /*!< Software Interrupt on line 16 */ +#define EXTI_SWIER1_SWI18_Pos (18U) +#define EXTI_SWIER1_SWI18_Msk (0x1UL << EXTI_SWIER1_SWI18_Pos) /*!< 0x00040000 */ +#define EXTI_SWIER1_SWI18 EXTI_SWIER1_SWI18_Msk /*!< Software Interrupt on line 18 */ +#define EXTI_SWIER1_SWI19_Pos (19U) +#define EXTI_SWIER1_SWI19_Msk (0x1UL << EXTI_SWIER1_SWI19_Pos) /*!< 0x00080000 */ +#define EXTI_SWIER1_SWI19 EXTI_SWIER1_SWI19_Msk /*!< Software Interrupt on line 19 */ +#define EXTI_SWIER1_SWI20_Pos (20U) +#define EXTI_SWIER1_SWI20_Msk (0x1UL << EXTI_SWIER1_SWI20_Pos) /*!< 0x00100000 */ +#define EXTI_SWIER1_SWI20 EXTI_SWIER1_SWI20_Msk /*!< Software Interrupt on line 20 */ +#define EXTI_SWIER1_SWI21_Pos (21U) +#define EXTI_SWIER1_SWI21_Msk (0x1UL << EXTI_SWIER1_SWI21_Pos) /*!< 0x00200000 */ +#define EXTI_SWIER1_SWI21 EXTI_SWIER1_SWI21_Msk /*!< Software Interrupt on line 21 */ + +/******************* Bit definition for EXTI_PR1 register *******************/ +#define EXTI_PR1_PIF0_Pos (0U) +#define EXTI_PR1_PIF0_Msk (0x1UL << EXTI_PR1_PIF0_Pos) /*!< 0x00000001 */ +#define EXTI_PR1_PIF0 EXTI_PR1_PIF0_Msk /*!< Pending bit for line 0 */ +#define EXTI_PR1_PIF1_Pos (1U) +#define EXTI_PR1_PIF1_Msk (0x1UL << EXTI_PR1_PIF1_Pos) /*!< 0x00000002 */ +#define EXTI_PR1_PIF1 EXTI_PR1_PIF1_Msk /*!< Pending bit for line 1 */ +#define EXTI_PR1_PIF2_Pos (2U) +#define EXTI_PR1_PIF2_Msk (0x1UL << EXTI_PR1_PIF2_Pos) /*!< 0x00000004 */ +#define EXTI_PR1_PIF2 EXTI_PR1_PIF2_Msk /*!< Pending bit for line 2 */ +#define EXTI_PR1_PIF3_Pos (3U) +#define EXTI_PR1_PIF3_Msk (0x1UL << EXTI_PR1_PIF3_Pos) /*!< 0x00000008 */ +#define EXTI_PR1_PIF3 EXTI_PR1_PIF3_Msk /*!< Pending bit for line 3 */ +#define EXTI_PR1_PIF4_Pos (4U) +#define EXTI_PR1_PIF4_Msk (0x1UL << EXTI_PR1_PIF4_Pos) /*!< 0x00000010 */ +#define EXTI_PR1_PIF4 EXTI_PR1_PIF4_Msk /*!< Pending bit for line 4 */ +#define EXTI_PR1_PIF5_Pos (5U) +#define EXTI_PR1_PIF5_Msk (0x1UL << EXTI_PR1_PIF5_Pos) /*!< 0x00000020 */ +#define EXTI_PR1_PIF5 EXTI_PR1_PIF5_Msk /*!< Pending bit for line 5 */ +#define EXTI_PR1_PIF6_Pos (6U) +#define EXTI_PR1_PIF6_Msk (0x1UL << EXTI_PR1_PIF6_Pos) /*!< 0x00000040 */ +#define EXTI_PR1_PIF6 EXTI_PR1_PIF6_Msk /*!< Pending bit for line 6 */ +#define EXTI_PR1_PIF7_Pos (7U) +#define EXTI_PR1_PIF7_Msk (0x1UL << EXTI_PR1_PIF7_Pos) /*!< 0x00000080 */ +#define EXTI_PR1_PIF7 EXTI_PR1_PIF7_Msk /*!< Pending bit for line 7 */ +#define EXTI_PR1_PIF8_Pos (8U) +#define EXTI_PR1_PIF8_Msk (0x1UL << EXTI_PR1_PIF8_Pos) /*!< 0x00000100 */ +#define EXTI_PR1_PIF8 EXTI_PR1_PIF8_Msk /*!< Pending bit for line 8 */ +#define EXTI_PR1_PIF9_Pos (9U) +#define EXTI_PR1_PIF9_Msk (0x1UL << EXTI_PR1_PIF9_Pos) /*!< 0x00000200 */ +#define EXTI_PR1_PIF9 EXTI_PR1_PIF9_Msk /*!< Pending bit for line 9 */ +#define EXTI_PR1_PIF10_Pos (10U) +#define EXTI_PR1_PIF10_Msk (0x1UL << EXTI_PR1_PIF10_Pos) /*!< 0x00000400 */ +#define EXTI_PR1_PIF10 EXTI_PR1_PIF10_Msk /*!< Pending bit for line 10 */ +#define EXTI_PR1_PIF11_Pos (11U) +#define EXTI_PR1_PIF11_Msk (0x1UL << EXTI_PR1_PIF11_Pos) /*!< 0x00000800 */ +#define EXTI_PR1_PIF11 EXTI_PR1_PIF11_Msk /*!< Pending bit for line 11 */ +#define EXTI_PR1_PIF12_Pos (12U) +#define EXTI_PR1_PIF12_Msk (0x1UL << EXTI_PR1_PIF12_Pos) /*!< 0x00001000 */ +#define EXTI_PR1_PIF12 EXTI_PR1_PIF12_Msk /*!< Pending bit for line 12 */ +#define EXTI_PR1_PIF13_Pos (13U) +#define EXTI_PR1_PIF13_Msk (0x1UL << EXTI_PR1_PIF13_Pos) /*!< 0x00002000 */ +#define EXTI_PR1_PIF13 EXTI_PR1_PIF13_Msk /*!< Pending bit for line 13 */ +#define EXTI_PR1_PIF14_Pos (14U) +#define EXTI_PR1_PIF14_Msk (0x1UL << EXTI_PR1_PIF14_Pos) /*!< 0x00004000 */ +#define EXTI_PR1_PIF14 EXTI_PR1_PIF14_Msk /*!< Pending bit for line 14 */ +#define EXTI_PR1_PIF15_Pos (15U) +#define EXTI_PR1_PIF15_Msk (0x1UL << EXTI_PR1_PIF15_Pos) /*!< 0x00008000 */ +#define EXTI_PR1_PIF15 EXTI_PR1_PIF15_Msk /*!< Pending bit for line 15 */ +#define EXTI_PR1_PIF16_Pos (16U) +#define EXTI_PR1_PIF16_Msk (0x1UL << EXTI_PR1_PIF16_Pos) /*!< 0x00010000 */ +#define EXTI_PR1_PIF16 EXTI_PR1_PIF16_Msk /*!< Pending bit for line 16 */ +#define EXTI_PR1_PIF18_Pos (18U) +#define EXTI_PR1_PIF18_Msk (0x1UL << EXTI_PR1_PIF18_Pos) /*!< 0x00040000 */ +#define EXTI_PR1_PIF18 EXTI_PR1_PIF18_Msk /*!< Pending bit for line 18 */ +#define EXTI_PR1_PIF19_Pos (19U) +#define EXTI_PR1_PIF19_Msk (0x1UL << EXTI_PR1_PIF19_Pos) /*!< 0x00080000 */ +#define EXTI_PR1_PIF19 EXTI_PR1_PIF19_Msk /*!< Pending bit for line 19 */ +#define EXTI_PR1_PIF20_Pos (20U) +#define EXTI_PR1_PIF20_Msk (0x1UL << EXTI_PR1_PIF20_Pos) /*!< 0x00100000 */ +#define EXTI_PR1_PIF20 EXTI_PR1_PIF20_Msk /*!< Pending bit for line 20 */ +#define EXTI_PR1_PIF21_Pos (21U) +#define EXTI_PR1_PIF21_Msk (0x1UL << EXTI_PR1_PIF21_Pos) /*!< 0x00200000 */ +#define EXTI_PR1_PIF21 EXTI_PR1_PIF21_Msk /*!< Pending bit for line 21 */ + +/******************* Bit definition for EXTI_IMR2 register ******************/ +#define EXTI_IMR2_IM32_Pos (0U) +#define EXTI_IMR2_IM32_Msk (0x1UL << EXTI_IMR2_IM32_Pos) /*!< 0x00000001 */ +#define EXTI_IMR2_IM32 EXTI_IMR2_IM32_Msk /*!< Interrupt Mask on line 32 */ +#define EXTI_IMR2_IM33_Pos (1U) +#define EXTI_IMR2_IM33_Msk (0x1UL << EXTI_IMR2_IM33_Pos) /*!< 0x00000002 */ +#define EXTI_IMR2_IM33 EXTI_IMR2_IM33_Msk /*!< Interrupt Mask on line 33 */ +#define EXTI_IMR2_IM35_Pos (3U) +#define EXTI_IMR2_IM35_Msk (0x1UL << EXTI_IMR2_IM35_Pos) /*!< 0x00000008 */ +#define EXTI_IMR2_IM35 EXTI_IMR2_IM35_Msk /*!< Interrupt Mask on line 35 */ +#define EXTI_IMR2_IM37_Pos (5U) +#define EXTI_IMR2_IM37_Msk (0x1UL << EXTI_IMR2_IM37_Pos) /*!< 0x00000020 */ +#define EXTI_IMR2_IM37 EXTI_IMR2_IM37_Msk /*!< Interrupt Mask on line 37 */ +#define EXTI_IMR2_IM38_Pos (6U) +#define EXTI_IMR2_IM38_Msk (0x1UL << EXTI_IMR2_IM38_Pos) /*!< 0x00000040 */ +#define EXTI_IMR2_IM38 EXTI_IMR2_IM38_Msk /*!< Interrupt Mask on line 38 */ +#define EXTI_IMR2_IM_Pos (0U) +#define EXTI_IMR2_IM_Msk (0x6BUL << EXTI_IMR2_IM_Pos) /*!< 0x0000006B */ +#define EXTI_IMR2_IM EXTI_IMR2_IM_Msk /*!< Interrupt Mask all */ + +/******************* Bit definition for EXTI_EMR2 register ******************/ +#define EXTI_EMR2_EM32_Pos (0U) +#define EXTI_EMR2_EM32_Msk (0x1UL << EXTI_EMR2_EM32_Pos) /*!< 0x00000001 */ +#define EXTI_EMR2_EM32 EXTI_EMR2_EM32_Msk /*!< Event Mask on line 32 */ +#define EXTI_EMR2_EM33_Pos (1U) +#define EXTI_EMR2_EM33_Msk (0x1UL << EXTI_EMR2_EM33_Pos) /*!< 0x00000002 */ +#define EXTI_EMR2_EM33 EXTI_EMR2_EM33_Msk /*!< Event Mask on line 33 */ +#define EXTI_EMR2_EM35_Pos (3U) +#define EXTI_EMR2_EM35_Msk (0x1UL << EXTI_EMR2_EM35_Pos) /*!< 0x00000008 */ +#define EXTI_EMR2_EM35 EXTI_EMR2_EM35_Msk /*!< Event Mask on line 35 */ +#define EXTI_EMR2_EM37_Pos (5U) +#define EXTI_EMR2_EM37_Msk (0x1UL << EXTI_EMR2_EM37_Pos) /*!< 0x00000020 */ +#define EXTI_EMR2_EM37 EXTI_EMR2_EM37_Msk /*!< Event Mask on line 37 */ +#define EXTI_EMR2_EM38_Pos (6U) +#define EXTI_EMR2_EM38_Msk (0x1UL << EXTI_EMR2_EM38_Pos) /*!< 0x00000040 */ +#define EXTI_EMR2_EM38 EXTI_EMR2_EM38_Msk /*!< Event Mask on line 38 */ +#define EXTI_EMR2_EM_Pos (0U) +#define EXTI_EMR2_EM_Msk (0x6BUL << EXTI_EMR2_EM_Pos) /*!< 0x0000006B */ +#define EXTI_EMR2_EM EXTI_EMR2_EM_Msk /*!< Interrupt Mask all */ + +/****************** Bit definition for EXTI_RTSR2 register ******************/ +#define EXTI_RTSR2_RT35_Pos (3U) +#define EXTI_RTSR2_RT35_Msk (0x1UL << EXTI_RTSR2_RT35_Pos) /*!< 0x00000008 */ +#define EXTI_RTSR2_RT35 EXTI_RTSR2_RT35_Msk /*!< Rising trigger event configuration bit of line 35 */ +#define EXTI_RTSR2_RT37_Pos (5U) +#define EXTI_RTSR2_RT37_Msk (0x1UL << EXTI_RTSR2_RT37_Pos) /*!< 0x00000020 */ +#define EXTI_RTSR2_RT37 EXTI_RTSR2_RT37_Msk /*!< Rising trigger event configuration bit of line 37 */ +#define EXTI_RTSR2_RT38_Pos (6U) +#define EXTI_RTSR2_RT38_Msk (0x1UL << EXTI_RTSR2_RT38_Pos) /*!< 0x00000040 */ +#define EXTI_RTSR2_RT38 EXTI_RTSR2_RT38_Msk /*!< Rising trigger event configuration bit of line 38 */ + +/****************** Bit definition for EXTI_FTSR2 register ******************/ +#define EXTI_FTSR2_FT35_Pos (3U) +#define EXTI_FTSR2_FT35_Msk (0x1UL << EXTI_FTSR2_FT35_Pos) /*!< 0x00000008 */ +#define EXTI_FTSR2_FT35 EXTI_FTSR2_FT35_Msk /*!< Falling trigger event configuration bit of line 35 */ +#define EXTI_FTSR2_FT37_Pos (5U) +#define EXTI_FTSR2_FT37_Msk (0x1UL << EXTI_FTSR2_FT37_Pos) /*!< 0x00000020 */ +#define EXTI_FTSR2_FT37 EXTI_FTSR2_FT37_Msk /*!< Falling trigger event configuration bit of line 37 */ +#define EXTI_FTSR2_FT38_Pos (6U) +#define EXTI_FTSR2_FT38_Msk (0x1UL << EXTI_FTSR2_FT38_Pos) /*!< 0x00000040 */ +#define EXTI_FTSR2_FT38 EXTI_FTSR2_FT38_Msk /*!< Falling trigger event configuration bit of line 38 */ + +/****************** Bit definition for EXTI_SWIER2 register *****************/ +#define EXTI_SWIER2_SWI35_Pos (3U) +#define EXTI_SWIER2_SWI35_Msk (0x1UL << EXTI_SWIER2_SWI35_Pos) /*!< 0x00000008 */ +#define EXTI_SWIER2_SWI35 EXTI_SWIER2_SWI35_Msk /*!< Software Interrupt on line 35 */ +#define EXTI_SWIER2_SWI37_Pos (5U) +#define EXTI_SWIER2_SWI37_Msk (0x1UL << EXTI_SWIER2_SWI37_Pos) /*!< 0x00000020 */ +#define EXTI_SWIER2_SWI37 EXTI_SWIER2_SWI37_Msk /*!< Software Interrupt on line 37 */ +#define EXTI_SWIER2_SWI38_Pos (6U) +#define EXTI_SWIER2_SWI38_Msk (0x1UL << EXTI_SWIER2_SWI38_Pos) /*!< 0x00000040 */ +#define EXTI_SWIER2_SWI38 EXTI_SWIER2_SWI38_Msk /*!< Software Interrupt on line 38 */ + +/******************* Bit definition for EXTI_PR2 register *******************/ +#define EXTI_PR2_PIF35_Pos (3U) +#define EXTI_PR2_PIF35_Msk (0x1UL << EXTI_PR2_PIF35_Pos) /*!< 0x00000008 */ +#define EXTI_PR2_PIF35 EXTI_PR2_PIF35_Msk /*!< Pending bit for line 35 */ +#define EXTI_PR2_PIF37_Pos (5U) +#define EXTI_PR2_PIF37_Msk (0x1UL << EXTI_PR2_PIF37_Pos) /*!< 0x00000020 */ +#define EXTI_PR2_PIF37 EXTI_PR2_PIF37_Msk /*!< Pending bit for line 37 */ +#define EXTI_PR2_PIF38_Pos (6U) +#define EXTI_PR2_PIF38_Msk (0x1UL << EXTI_PR2_PIF38_Pos) /*!< 0x00000040 */ +#define EXTI_PR2_PIF38 EXTI_PR2_PIF38_Msk /*!< Pending bit for line 38 */ + + +/******************************************************************************/ +/* */ +/* FLASH */ +/* */ +/******************************************************************************/ +/******************* Bits definition for FLASH_ACR register *****************/ +#define FLASH_ACR_LATENCY_Pos (0U) +#define FLASH_ACR_LATENCY_Msk (0x7UL << FLASH_ACR_LATENCY_Pos) /*!< 0x00000007 */ +#define FLASH_ACR_LATENCY FLASH_ACR_LATENCY_Msk +#define FLASH_ACR_LATENCY_0WS (0x00000000UL) +#define FLASH_ACR_LATENCY_1WS (0x00000001UL) +#define FLASH_ACR_LATENCY_2WS (0x00000002UL) +#define FLASH_ACR_LATENCY_3WS (0x00000003UL) +#define FLASH_ACR_LATENCY_4WS (0x00000004UL) +#define FLASH_ACR_PRFTEN_Pos (8U) +#define FLASH_ACR_PRFTEN_Msk (0x1UL << FLASH_ACR_PRFTEN_Pos) /*!< 0x00000100 */ +#define FLASH_ACR_PRFTEN FLASH_ACR_PRFTEN_Msk +#define FLASH_ACR_ICEN_Pos (9U) +#define FLASH_ACR_ICEN_Msk (0x1UL << FLASH_ACR_ICEN_Pos) /*!< 0x00000200 */ +#define FLASH_ACR_ICEN FLASH_ACR_ICEN_Msk +#define FLASH_ACR_DCEN_Pos (10U) +#define FLASH_ACR_DCEN_Msk (0x1UL << FLASH_ACR_DCEN_Pos) /*!< 0x00000400 */ +#define FLASH_ACR_DCEN FLASH_ACR_DCEN_Msk +#define FLASH_ACR_ICRST_Pos (11U) +#define FLASH_ACR_ICRST_Msk (0x1UL << FLASH_ACR_ICRST_Pos) /*!< 0x00000800 */ +#define FLASH_ACR_ICRST FLASH_ACR_ICRST_Msk +#define FLASH_ACR_DCRST_Pos (12U) +#define FLASH_ACR_DCRST_Msk (0x1UL << FLASH_ACR_DCRST_Pos) /*!< 0x00001000 */ +#define FLASH_ACR_DCRST FLASH_ACR_DCRST_Msk +#define FLASH_ACR_RUN_PD_Pos (13U) +#define FLASH_ACR_RUN_PD_Msk (0x1UL << FLASH_ACR_RUN_PD_Pos) /*!< 0x00002000 */ +#define FLASH_ACR_RUN_PD FLASH_ACR_RUN_PD_Msk /*!< Flash power down mode during run */ +#define FLASH_ACR_SLEEP_PD_Pos (14U) +#define FLASH_ACR_SLEEP_PD_Msk (0x1UL << FLASH_ACR_SLEEP_PD_Pos) /*!< 0x00004000 */ +#define FLASH_ACR_SLEEP_PD FLASH_ACR_SLEEP_PD_Msk /*!< Flash power down mode during sleep */ + +/******************* Bits definition for FLASH_SR register ******************/ +#define FLASH_SR_EOP_Pos (0U) +#define FLASH_SR_EOP_Msk (0x1UL << FLASH_SR_EOP_Pos) /*!< 0x00000001 */ +#define FLASH_SR_EOP FLASH_SR_EOP_Msk +#define FLASH_SR_OPERR_Pos (1U) +#define FLASH_SR_OPERR_Msk (0x1UL << FLASH_SR_OPERR_Pos) /*!< 0x00000002 */ +#define FLASH_SR_OPERR FLASH_SR_OPERR_Msk +#define FLASH_SR_PROGERR_Pos (3U) +#define FLASH_SR_PROGERR_Msk (0x1UL << FLASH_SR_PROGERR_Pos) /*!< 0x00000008 */ +#define FLASH_SR_PROGERR FLASH_SR_PROGERR_Msk +#define FLASH_SR_WRPERR_Pos (4U) +#define FLASH_SR_WRPERR_Msk (0x1UL << FLASH_SR_WRPERR_Pos) /*!< 0x00000010 */ +#define FLASH_SR_WRPERR FLASH_SR_WRPERR_Msk +#define FLASH_SR_PGAERR_Pos (5U) +#define FLASH_SR_PGAERR_Msk (0x1UL << FLASH_SR_PGAERR_Pos) /*!< 0x00000020 */ +#define FLASH_SR_PGAERR FLASH_SR_PGAERR_Msk +#define FLASH_SR_SIZERR_Pos (6U) +#define FLASH_SR_SIZERR_Msk (0x1UL << FLASH_SR_SIZERR_Pos) /*!< 0x00000040 */ +#define FLASH_SR_SIZERR FLASH_SR_SIZERR_Msk +#define FLASH_SR_PGSERR_Pos (7U) +#define FLASH_SR_PGSERR_Msk (0x1UL << FLASH_SR_PGSERR_Pos) /*!< 0x00000080 */ +#define FLASH_SR_PGSERR FLASH_SR_PGSERR_Msk +#define FLASH_SR_MISERR_Pos (8U) +#define FLASH_SR_MISERR_Msk (0x1UL << FLASH_SR_MISERR_Pos) /*!< 0x00000100 */ +#define FLASH_SR_MISERR FLASH_SR_MISERR_Msk +#define FLASH_SR_FASTERR_Pos (9U) +#define FLASH_SR_FASTERR_Msk (0x1UL << FLASH_SR_FASTERR_Pos) /*!< 0x00000200 */ +#define FLASH_SR_FASTERR FLASH_SR_FASTERR_Msk +#define FLASH_SR_RDERR_Pos (14U) +#define FLASH_SR_RDERR_Msk (0x1UL << FLASH_SR_RDERR_Pos) /*!< 0x00004000 */ +#define FLASH_SR_RDERR FLASH_SR_RDERR_Msk +#define FLASH_SR_OPTVERR_Pos (15U) +#define FLASH_SR_OPTVERR_Msk (0x1UL << FLASH_SR_OPTVERR_Pos) /*!< 0x00008000 */ +#define FLASH_SR_OPTVERR FLASH_SR_OPTVERR_Msk +#define FLASH_SR_BSY_Pos (16U) +#define FLASH_SR_BSY_Msk (0x1UL << FLASH_SR_BSY_Pos) /*!< 0x00010000 */ +#define FLASH_SR_BSY FLASH_SR_BSY_Msk +#define FLASH_SR_PEMPTY_Pos (17U) +#define FLASH_SR_PEMPTY_Msk (0x1UL << FLASH_SR_PEMPTY_Pos) /*!< 0x00020000 */ +#define FLASH_SR_PEMPTY FLASH_SR_PEMPTY_Msk + +/******************* Bits definition for FLASH_CR register ******************/ +#define FLASH_CR_PG_Pos (0U) +#define FLASH_CR_PG_Msk (0x1UL << FLASH_CR_PG_Pos) /*!< 0x00000001 */ +#define FLASH_CR_PG FLASH_CR_PG_Msk +#define FLASH_CR_PER_Pos (1U) +#define FLASH_CR_PER_Msk (0x1UL << FLASH_CR_PER_Pos) /*!< 0x00000002 */ +#define FLASH_CR_PER FLASH_CR_PER_Msk +#define FLASH_CR_MER1_Pos (2U) +#define FLASH_CR_MER1_Msk (0x1UL << FLASH_CR_MER1_Pos) /*!< 0x00000004 */ +#define FLASH_CR_MER1 FLASH_CR_MER1_Msk +#define FLASH_CR_PNB_Pos (3U) +#define FLASH_CR_PNB_Msk (0x3FUL << FLASH_CR_PNB_Pos) /*!< 0x000001F8 */ +#define FLASH_CR_PNB FLASH_CR_PNB_Msk +#define FLASH_CR_STRT_Pos (16U) +#define FLASH_CR_STRT_Msk (0x1UL << FLASH_CR_STRT_Pos) /*!< 0x00010000 */ +#define FLASH_CR_STRT FLASH_CR_STRT_Msk +#define FLASH_CR_OPTSTRT_Pos (17U) +#define FLASH_CR_OPTSTRT_Msk (0x1UL << FLASH_CR_OPTSTRT_Pos) /*!< 0x00020000 */ +#define FLASH_CR_OPTSTRT FLASH_CR_OPTSTRT_Msk +#define FLASH_CR_FSTPG_Pos (18U) +#define FLASH_CR_FSTPG_Msk (0x1UL << FLASH_CR_FSTPG_Pos) /*!< 0x00040000 */ +#define FLASH_CR_FSTPG FLASH_CR_FSTPG_Msk +#define FLASH_CR_EOPIE_Pos (24U) +#define FLASH_CR_EOPIE_Msk (0x1UL << FLASH_CR_EOPIE_Pos) /*!< 0x01000000 */ +#define FLASH_CR_EOPIE FLASH_CR_EOPIE_Msk +#define FLASH_CR_ERRIE_Pos (25U) +#define FLASH_CR_ERRIE_Msk (0x1UL << FLASH_CR_ERRIE_Pos) /*!< 0x02000000 */ +#define FLASH_CR_ERRIE FLASH_CR_ERRIE_Msk +#define FLASH_CR_RDERRIE_Pos (26U) +#define FLASH_CR_RDERRIE_Msk (0x1UL << FLASH_CR_RDERRIE_Pos) /*!< 0x04000000 */ +#define FLASH_CR_RDERRIE FLASH_CR_RDERRIE_Msk +#define FLASH_CR_OBL_LAUNCH_Pos (27U) +#define FLASH_CR_OBL_LAUNCH_Msk (0x1UL << FLASH_CR_OBL_LAUNCH_Pos) /*!< 0x08000000 */ +#define FLASH_CR_OBL_LAUNCH FLASH_CR_OBL_LAUNCH_Msk +#define FLASH_CR_OPTLOCK_Pos (30U) +#define FLASH_CR_OPTLOCK_Msk (0x1UL << FLASH_CR_OPTLOCK_Pos) /*!< 0x40000000 */ +#define FLASH_CR_OPTLOCK FLASH_CR_OPTLOCK_Msk +#define FLASH_CR_LOCK_Pos (31U) +#define FLASH_CR_LOCK_Msk (0x1UL << FLASH_CR_LOCK_Pos) /*!< 0x80000000 */ +#define FLASH_CR_LOCK FLASH_CR_LOCK_Msk + +/******************* Bits definition for FLASH_ECCR register ***************/ +#define FLASH_ECCR_ADDR_ECC_Pos (0U) +#define FLASH_ECCR_ADDR_ECC_Msk (0x7FFFFUL << FLASH_ECCR_ADDR_ECC_Pos) /*!< 0x0007FFFF */ +#define FLASH_ECCR_ADDR_ECC FLASH_ECCR_ADDR_ECC_Msk +#define FLASH_ECCR_SYSF_ECC_Pos (20U) +#define FLASH_ECCR_SYSF_ECC_Msk (0x1UL << FLASH_ECCR_SYSF_ECC_Pos) /*!< 0x00100000 */ +#define FLASH_ECCR_SYSF_ECC FLASH_ECCR_SYSF_ECC_Msk +#define FLASH_ECCR_ECCIE_Pos (24U) +#define FLASH_ECCR_ECCIE_Msk (0x1UL << FLASH_ECCR_ECCIE_Pos) /*!< 0x01000000 */ +#define FLASH_ECCR_ECCIE FLASH_ECCR_ECCIE_Msk +#define FLASH_ECCR_ECCC_Pos (30U) +#define FLASH_ECCR_ECCC_Msk (0x1UL << FLASH_ECCR_ECCC_Pos) /*!< 0x40000000 */ +#define FLASH_ECCR_ECCC FLASH_ECCR_ECCC_Msk +#define FLASH_ECCR_ECCD_Pos (31U) +#define FLASH_ECCR_ECCD_Msk (0x1UL << FLASH_ECCR_ECCD_Pos) /*!< 0x80000000 */ +#define FLASH_ECCR_ECCD FLASH_ECCR_ECCD_Msk + +/******************* Bits definition for FLASH_OPTR register ***************/ +#define FLASH_OPTR_RDP_Pos (0U) +#define FLASH_OPTR_RDP_Msk (0xFFUL << FLASH_OPTR_RDP_Pos) /*!< 0x000000FF */ +#define FLASH_OPTR_RDP FLASH_OPTR_RDP_Msk +#define FLASH_OPTR_BOR_LEV_Pos (8U) +#define FLASH_OPTR_BOR_LEV_Msk (0x7UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000700 */ +#define FLASH_OPTR_BOR_LEV FLASH_OPTR_BOR_LEV_Msk +#define FLASH_OPTR_BOR_LEV_0 (0x0UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000000 */ +#define FLASH_OPTR_BOR_LEV_1 (0x1UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000100 */ +#define FLASH_OPTR_BOR_LEV_2 (0x2UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000200 */ +#define FLASH_OPTR_BOR_LEV_3 (0x3UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000300 */ +#define FLASH_OPTR_BOR_LEV_4 (0x4UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000400 */ +#define FLASH_OPTR_nRST_STOP_Pos (12U) +#define FLASH_OPTR_nRST_STOP_Msk (0x1UL << FLASH_OPTR_nRST_STOP_Pos) /*!< 0x00001000 */ +#define FLASH_OPTR_nRST_STOP FLASH_OPTR_nRST_STOP_Msk +#define FLASH_OPTR_nRST_STDBY_Pos (13U) +#define FLASH_OPTR_nRST_STDBY_Msk (0x1UL << FLASH_OPTR_nRST_STDBY_Pos) /*!< 0x00002000 */ +#define FLASH_OPTR_nRST_STDBY FLASH_OPTR_nRST_STDBY_Msk +#define FLASH_OPTR_nRST_SHDW_Pos (14U) +#define FLASH_OPTR_nRST_SHDW_Msk (0x1UL << FLASH_OPTR_nRST_SHDW_Pos) /*!< 0x00004000 */ +#define FLASH_OPTR_nRST_SHDW FLASH_OPTR_nRST_SHDW_Msk +#define FLASH_OPTR_IWDG_SW_Pos (16U) +#define FLASH_OPTR_IWDG_SW_Msk (0x1UL << FLASH_OPTR_IWDG_SW_Pos) /*!< 0x00010000 */ +#define FLASH_OPTR_IWDG_SW FLASH_OPTR_IWDG_SW_Msk +#define FLASH_OPTR_IWDG_STOP_Pos (17U) +#define FLASH_OPTR_IWDG_STOP_Msk (0x1UL << FLASH_OPTR_IWDG_STOP_Pos) /*!< 0x00020000 */ +#define FLASH_OPTR_IWDG_STOP FLASH_OPTR_IWDG_STOP_Msk +#define FLASH_OPTR_IWDG_STDBY_Pos (18U) +#define FLASH_OPTR_IWDG_STDBY_Msk (0x1UL << FLASH_OPTR_IWDG_STDBY_Pos) /*!< 0x00040000 */ +#define FLASH_OPTR_IWDG_STDBY FLASH_OPTR_IWDG_STDBY_Msk +#define FLASH_OPTR_WWDG_SW_Pos (19U) +#define FLASH_OPTR_WWDG_SW_Msk (0x1UL << FLASH_OPTR_WWDG_SW_Pos) /*!< 0x00080000 */ +#define FLASH_OPTR_WWDG_SW FLASH_OPTR_WWDG_SW_Msk +#define FLASH_OPTR_nBOOT1_Pos (23U) +#define FLASH_OPTR_nBOOT1_Msk (0x1UL << FLASH_OPTR_nBOOT1_Pos) /*!< 0x00800000 */ +#define FLASH_OPTR_nBOOT1 FLASH_OPTR_nBOOT1_Msk +#define FLASH_OPTR_SRAM2_PE_Pos (24U) +#define FLASH_OPTR_SRAM2_PE_Msk (0x1UL << FLASH_OPTR_SRAM2_PE_Pos) /*!< 0x01000000 */ +#define FLASH_OPTR_SRAM2_PE FLASH_OPTR_SRAM2_PE_Msk +#define FLASH_OPTR_SRAM2_RST_Pos (25U) +#define FLASH_OPTR_SRAM2_RST_Msk (0x1UL << FLASH_OPTR_SRAM2_RST_Pos) /*!< 0x02000000 */ +#define FLASH_OPTR_SRAM2_RST FLASH_OPTR_SRAM2_RST_Msk +#define FLASH_OPTR_nSWBOOT0_Pos (26U) +#define FLASH_OPTR_nSWBOOT0_Msk (0x1UL << FLASH_OPTR_nSWBOOT0_Pos) /*!< 0x04000000 */ +#define FLASH_OPTR_nSWBOOT0 FLASH_OPTR_nSWBOOT0_Msk +#define FLASH_OPTR_nBOOT0_Pos (27U) +#define FLASH_OPTR_nBOOT0_Msk (0x1UL << FLASH_OPTR_nBOOT0_Pos) /*!< 0x08000000 */ +#define FLASH_OPTR_nBOOT0 FLASH_OPTR_nBOOT0_Msk + +/****************** Bits definition for FLASH_PCROP1SR register **********/ +#define FLASH_PCROP1SR_PCROP1_STRT_Pos (0U) +#define FLASH_PCROP1SR_PCROP1_STRT_Msk (0x3FFFUL << FLASH_PCROP1SR_PCROP1_STRT_Pos) /*!< 0x00003FFF */ +#define FLASH_PCROP1SR_PCROP1_STRT FLASH_PCROP1SR_PCROP1_STRT_Msk + +/****************** Bits definition for FLASH_PCROP1ER register ***********/ +#define FLASH_PCROP1ER_PCROP1_END_Pos (0U) +#define FLASH_PCROP1ER_PCROP1_END_Msk (0x3FFFUL << FLASH_PCROP1ER_PCROP1_END_Pos) /*!< 0x00003FFF */ +#define FLASH_PCROP1ER_PCROP1_END FLASH_PCROP1ER_PCROP1_END_Msk +#define FLASH_PCROP1ER_PCROP_RDP_Pos (31U) +#define FLASH_PCROP1ER_PCROP_RDP_Msk (0x1UL << FLASH_PCROP1ER_PCROP_RDP_Pos) /*!< 0x80000000 */ +#define FLASH_PCROP1ER_PCROP_RDP FLASH_PCROP1ER_PCROP_RDP_Msk + +/****************** Bits definition for FLASH_WRP1AR register ***************/ +#define FLASH_WRP1AR_WRP1A_STRT_Pos (0U) +#define FLASH_WRP1AR_WRP1A_STRT_Msk (0x3FUL << FLASH_WRP1AR_WRP1A_STRT_Pos) /*!< 0x0000003F */ +#define FLASH_WRP1AR_WRP1A_STRT FLASH_WRP1AR_WRP1A_STRT_Msk +#define FLASH_WRP1AR_WRP1A_END_Pos (16U) +#define FLASH_WRP1AR_WRP1A_END_Msk (0x3FUL << FLASH_WRP1AR_WRP1A_END_Pos) /*!< 0x003F0000 */ +#define FLASH_WRP1AR_WRP1A_END FLASH_WRP1AR_WRP1A_END_Msk + +/****************** Bits definition for FLASH_WRPB1R register ***************/ +#define FLASH_WRP1BR_WRP1B_STRT_Pos (0U) +#define FLASH_WRP1BR_WRP1B_STRT_Msk (0x3FUL << FLASH_WRP1BR_WRP1B_STRT_Pos) /*!< 0x0000003F */ +#define FLASH_WRP1BR_WRP1B_STRT FLASH_WRP1BR_WRP1B_STRT_Msk +#define FLASH_WRP1BR_WRP1B_END_Pos (16U) +#define FLASH_WRP1BR_WRP1B_END_Msk (0x3FUL << FLASH_WRP1BR_WRP1B_END_Pos) /*!< 0x003F0000 */ +#define FLASH_WRP1BR_WRP1B_END FLASH_WRP1BR_WRP1B_END_Msk + + + + +/******************************************************************************/ +/* */ +/* General Purpose IOs (GPIO) */ +/* */ +/******************************************************************************/ +/****************** Bits definition for GPIO_MODER register *****************/ +#define GPIO_MODER_MODE0_Pos (0U) +#define GPIO_MODER_MODE0_Msk (0x3UL << GPIO_MODER_MODE0_Pos) /*!< 0x00000003 */ +#define GPIO_MODER_MODE0 GPIO_MODER_MODE0_Msk +#define GPIO_MODER_MODE0_0 (0x1UL << GPIO_MODER_MODE0_Pos) /*!< 0x00000001 */ +#define GPIO_MODER_MODE0_1 (0x2UL << GPIO_MODER_MODE0_Pos) /*!< 0x00000002 */ +#define GPIO_MODER_MODE1_Pos (2U) +#define GPIO_MODER_MODE1_Msk (0x3UL << GPIO_MODER_MODE1_Pos) /*!< 0x0000000C */ +#define GPIO_MODER_MODE1 GPIO_MODER_MODE1_Msk +#define GPIO_MODER_MODE1_0 (0x1UL << GPIO_MODER_MODE1_Pos) /*!< 0x00000004 */ +#define GPIO_MODER_MODE1_1 (0x2UL << GPIO_MODER_MODE1_Pos) /*!< 0x00000008 */ +#define GPIO_MODER_MODE2_Pos (4U) +#define GPIO_MODER_MODE2_Msk (0x3UL << GPIO_MODER_MODE2_Pos) /*!< 0x00000030 */ +#define GPIO_MODER_MODE2 GPIO_MODER_MODE2_Msk +#define GPIO_MODER_MODE2_0 (0x1UL << GPIO_MODER_MODE2_Pos) /*!< 0x00000010 */ +#define GPIO_MODER_MODE2_1 (0x2UL << GPIO_MODER_MODE2_Pos) /*!< 0x00000020 */ +#define GPIO_MODER_MODE3_Pos (6U) +#define GPIO_MODER_MODE3_Msk (0x3UL << GPIO_MODER_MODE3_Pos) /*!< 0x000000C0 */ +#define GPIO_MODER_MODE3 GPIO_MODER_MODE3_Msk +#define GPIO_MODER_MODE3_0 (0x1UL << GPIO_MODER_MODE3_Pos) /*!< 0x00000040 */ +#define GPIO_MODER_MODE3_1 (0x2UL << GPIO_MODER_MODE3_Pos) /*!< 0x00000080 */ +#define GPIO_MODER_MODE4_Pos (8U) +#define GPIO_MODER_MODE4_Msk (0x3UL << GPIO_MODER_MODE4_Pos) /*!< 0x00000300 */ +#define GPIO_MODER_MODE4 GPIO_MODER_MODE4_Msk +#define GPIO_MODER_MODE4_0 (0x1UL << GPIO_MODER_MODE4_Pos) /*!< 0x00000100 */ +#define GPIO_MODER_MODE4_1 (0x2UL << GPIO_MODER_MODE4_Pos) /*!< 0x00000200 */ +#define GPIO_MODER_MODE5_Pos (10U) +#define GPIO_MODER_MODE5_Msk (0x3UL << GPIO_MODER_MODE5_Pos) /*!< 0x00000C00 */ +#define GPIO_MODER_MODE5 GPIO_MODER_MODE5_Msk +#define GPIO_MODER_MODE5_0 (0x1UL << GPIO_MODER_MODE5_Pos) /*!< 0x00000400 */ +#define GPIO_MODER_MODE5_1 (0x2UL << GPIO_MODER_MODE5_Pos) /*!< 0x00000800 */ +#define GPIO_MODER_MODE6_Pos (12U) +#define GPIO_MODER_MODE6_Msk (0x3UL << GPIO_MODER_MODE6_Pos) /*!< 0x00003000 */ +#define GPIO_MODER_MODE6 GPIO_MODER_MODE6_Msk +#define GPIO_MODER_MODE6_0 (0x1UL << GPIO_MODER_MODE6_Pos) /*!< 0x00001000 */ +#define GPIO_MODER_MODE6_1 (0x2UL << GPIO_MODER_MODE6_Pos) /*!< 0x00002000 */ +#define GPIO_MODER_MODE7_Pos (14U) +#define GPIO_MODER_MODE7_Msk (0x3UL << GPIO_MODER_MODE7_Pos) /*!< 0x0000C000 */ +#define GPIO_MODER_MODE7 GPIO_MODER_MODE7_Msk +#define GPIO_MODER_MODE7_0 (0x1UL << GPIO_MODER_MODE7_Pos) /*!< 0x00004000 */ +#define GPIO_MODER_MODE7_1 (0x2UL << GPIO_MODER_MODE7_Pos) /*!< 0x00008000 */ +#define GPIO_MODER_MODE8_Pos (16U) +#define GPIO_MODER_MODE8_Msk (0x3UL << GPIO_MODER_MODE8_Pos) /*!< 0x00030000 */ +#define GPIO_MODER_MODE8 GPIO_MODER_MODE8_Msk +#define GPIO_MODER_MODE8_0 (0x1UL << GPIO_MODER_MODE8_Pos) /*!< 0x00010000 */ +#define GPIO_MODER_MODE8_1 (0x2UL << GPIO_MODER_MODE8_Pos) /*!< 0x00020000 */ +#define GPIO_MODER_MODE9_Pos (18U) +#define GPIO_MODER_MODE9_Msk (0x3UL << GPIO_MODER_MODE9_Pos) /*!< 0x000C0000 */ +#define GPIO_MODER_MODE9 GPIO_MODER_MODE9_Msk +#define GPIO_MODER_MODE9_0 (0x1UL << GPIO_MODER_MODE9_Pos) /*!< 0x00040000 */ +#define GPIO_MODER_MODE9_1 (0x2UL << GPIO_MODER_MODE9_Pos) /*!< 0x00080000 */ +#define GPIO_MODER_MODE10_Pos (20U) +#define GPIO_MODER_MODE10_Msk (0x3UL << GPIO_MODER_MODE10_Pos) /*!< 0x00300000 */ +#define GPIO_MODER_MODE10 GPIO_MODER_MODE10_Msk +#define GPIO_MODER_MODE10_0 (0x1UL << GPIO_MODER_MODE10_Pos) /*!< 0x00100000 */ +#define GPIO_MODER_MODE10_1 (0x2UL << GPIO_MODER_MODE10_Pos) /*!< 0x00200000 */ +#define GPIO_MODER_MODE11_Pos (22U) +#define GPIO_MODER_MODE11_Msk (0x3UL << GPIO_MODER_MODE11_Pos) /*!< 0x00C00000 */ +#define GPIO_MODER_MODE11 GPIO_MODER_MODE11_Msk +#define GPIO_MODER_MODE11_0 (0x1UL << GPIO_MODER_MODE11_Pos) /*!< 0x00400000 */ +#define GPIO_MODER_MODE11_1 (0x2UL << GPIO_MODER_MODE11_Pos) /*!< 0x00800000 */ +#define GPIO_MODER_MODE12_Pos (24U) +#define GPIO_MODER_MODE12_Msk (0x3UL << GPIO_MODER_MODE12_Pos) /*!< 0x03000000 */ +#define GPIO_MODER_MODE12 GPIO_MODER_MODE12_Msk +#define GPIO_MODER_MODE12_0 (0x1UL << GPIO_MODER_MODE12_Pos) /*!< 0x01000000 */ +#define GPIO_MODER_MODE12_1 (0x2UL << GPIO_MODER_MODE12_Pos) /*!< 0x02000000 */ +#define GPIO_MODER_MODE13_Pos (26U) +#define GPIO_MODER_MODE13_Msk (0x3UL << GPIO_MODER_MODE13_Pos) /*!< 0x0C000000 */ +#define GPIO_MODER_MODE13 GPIO_MODER_MODE13_Msk +#define GPIO_MODER_MODE13_0 (0x1UL << GPIO_MODER_MODE13_Pos) /*!< 0x04000000 */ +#define GPIO_MODER_MODE13_1 (0x2UL << GPIO_MODER_MODE13_Pos) /*!< 0x08000000 */ +#define GPIO_MODER_MODE14_Pos (28U) +#define GPIO_MODER_MODE14_Msk (0x3UL << GPIO_MODER_MODE14_Pos) /*!< 0x30000000 */ +#define GPIO_MODER_MODE14 GPIO_MODER_MODE14_Msk +#define GPIO_MODER_MODE14_0 (0x1UL << GPIO_MODER_MODE14_Pos) /*!< 0x10000000 */ +#define GPIO_MODER_MODE14_1 (0x2UL << GPIO_MODER_MODE14_Pos) /*!< 0x20000000 */ +#define GPIO_MODER_MODE15_Pos (30U) +#define GPIO_MODER_MODE15_Msk (0x3UL << GPIO_MODER_MODE15_Pos) /*!< 0xC0000000 */ +#define GPIO_MODER_MODE15 GPIO_MODER_MODE15_Msk +#define GPIO_MODER_MODE15_0 (0x1UL << GPIO_MODER_MODE15_Pos) /*!< 0x40000000 */ +#define GPIO_MODER_MODE15_1 (0x2UL << GPIO_MODER_MODE15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_MODER_MODER0 GPIO_MODER_MODE0 +#define GPIO_MODER_MODER0_0 GPIO_MODER_MODE0_0 +#define GPIO_MODER_MODER0_1 GPIO_MODER_MODE0_1 +#define GPIO_MODER_MODER1 GPIO_MODER_MODE1 +#define GPIO_MODER_MODER1_0 GPIO_MODER_MODE1_0 +#define GPIO_MODER_MODER1_1 GPIO_MODER_MODE1_1 +#define GPIO_MODER_MODER2 GPIO_MODER_MODE2 +#define GPIO_MODER_MODER2_0 GPIO_MODER_MODE2_0 +#define GPIO_MODER_MODER2_1 GPIO_MODER_MODE2_1 +#define GPIO_MODER_MODER3 GPIO_MODER_MODE3 +#define GPIO_MODER_MODER3_0 GPIO_MODER_MODE3_0 +#define GPIO_MODER_MODER3_1 GPIO_MODER_MODE3_1 +#define GPIO_MODER_MODER4 GPIO_MODER_MODE4 +#define GPIO_MODER_MODER4_0 GPIO_MODER_MODE4_0 +#define GPIO_MODER_MODER4_1 GPIO_MODER_MODE4_1 +#define GPIO_MODER_MODER5 GPIO_MODER_MODE5 +#define GPIO_MODER_MODER5_0 GPIO_MODER_MODE5_0 +#define GPIO_MODER_MODER5_1 GPIO_MODER_MODE5_1 +#define GPIO_MODER_MODER6 GPIO_MODER_MODE6 +#define GPIO_MODER_MODER6_0 GPIO_MODER_MODE6_0 +#define GPIO_MODER_MODER6_1 GPIO_MODER_MODE6_1 +#define GPIO_MODER_MODER7 GPIO_MODER_MODE7 +#define GPIO_MODER_MODER7_0 GPIO_MODER_MODE7_0 +#define GPIO_MODER_MODER7_1 GPIO_MODER_MODE7_1 +#define GPIO_MODER_MODER8 GPIO_MODER_MODE8 +#define GPIO_MODER_MODER8_0 GPIO_MODER_MODE8_0 +#define GPIO_MODER_MODER8_1 GPIO_MODER_MODE8_1 +#define GPIO_MODER_MODER9 GPIO_MODER_MODE9 +#define GPIO_MODER_MODER9_0 GPIO_MODER_MODE9_0 +#define GPIO_MODER_MODER9_1 GPIO_MODER_MODE9_1 +#define GPIO_MODER_MODER10 GPIO_MODER_MODE10 +#define GPIO_MODER_MODER10_0 GPIO_MODER_MODE10_0 +#define GPIO_MODER_MODER10_1 GPIO_MODER_MODE10_1 +#define GPIO_MODER_MODER11 GPIO_MODER_MODE11 +#define GPIO_MODER_MODER11_0 GPIO_MODER_MODE11_0 +#define GPIO_MODER_MODER11_1 GPIO_MODER_MODE11_1 +#define GPIO_MODER_MODER12 GPIO_MODER_MODE12 +#define GPIO_MODER_MODER12_0 GPIO_MODER_MODE12_0 +#define GPIO_MODER_MODER12_1 GPIO_MODER_MODE12_1 +#define GPIO_MODER_MODER13 GPIO_MODER_MODE13 +#define GPIO_MODER_MODER13_0 GPIO_MODER_MODE13_0 +#define GPIO_MODER_MODER13_1 GPIO_MODER_MODE13_1 +#define GPIO_MODER_MODER14 GPIO_MODER_MODE14 +#define GPIO_MODER_MODER14_0 GPIO_MODER_MODE14_0 +#define GPIO_MODER_MODER14_1 GPIO_MODER_MODE14_1 +#define GPIO_MODER_MODER15 GPIO_MODER_MODE15 +#define GPIO_MODER_MODER15_0 GPIO_MODER_MODE15_0 +#define GPIO_MODER_MODER15_1 GPIO_MODER_MODE15_1 + +/****************** Bits definition for GPIO_OTYPER register ****************/ +#define GPIO_OTYPER_OT0_Pos (0U) +#define GPIO_OTYPER_OT0_Msk (0x1UL << GPIO_OTYPER_OT0_Pos) /*!< 0x00000001 */ +#define GPIO_OTYPER_OT0 GPIO_OTYPER_OT0_Msk +#define GPIO_OTYPER_OT1_Pos (1U) +#define GPIO_OTYPER_OT1_Msk (0x1UL << GPIO_OTYPER_OT1_Pos) /*!< 0x00000002 */ +#define GPIO_OTYPER_OT1 GPIO_OTYPER_OT1_Msk +#define GPIO_OTYPER_OT2_Pos (2U) +#define GPIO_OTYPER_OT2_Msk (0x1UL << GPIO_OTYPER_OT2_Pos) /*!< 0x00000004 */ +#define GPIO_OTYPER_OT2 GPIO_OTYPER_OT2_Msk +#define GPIO_OTYPER_OT3_Pos (3U) +#define GPIO_OTYPER_OT3_Msk (0x1UL << GPIO_OTYPER_OT3_Pos) /*!< 0x00000008 */ +#define GPIO_OTYPER_OT3 GPIO_OTYPER_OT3_Msk +#define GPIO_OTYPER_OT4_Pos (4U) +#define GPIO_OTYPER_OT4_Msk (0x1UL << GPIO_OTYPER_OT4_Pos) /*!< 0x00000010 */ +#define GPIO_OTYPER_OT4 GPIO_OTYPER_OT4_Msk +#define GPIO_OTYPER_OT5_Pos (5U) +#define GPIO_OTYPER_OT5_Msk (0x1UL << GPIO_OTYPER_OT5_Pos) /*!< 0x00000020 */ +#define GPIO_OTYPER_OT5 GPIO_OTYPER_OT5_Msk +#define GPIO_OTYPER_OT6_Pos (6U) +#define GPIO_OTYPER_OT6_Msk (0x1UL << GPIO_OTYPER_OT6_Pos) /*!< 0x00000040 */ +#define GPIO_OTYPER_OT6 GPIO_OTYPER_OT6_Msk +#define GPIO_OTYPER_OT7_Pos (7U) +#define GPIO_OTYPER_OT7_Msk (0x1UL << GPIO_OTYPER_OT7_Pos) /*!< 0x00000080 */ +#define GPIO_OTYPER_OT7 GPIO_OTYPER_OT7_Msk +#define GPIO_OTYPER_OT8_Pos (8U) +#define GPIO_OTYPER_OT8_Msk (0x1UL << GPIO_OTYPER_OT8_Pos) /*!< 0x00000100 */ +#define GPIO_OTYPER_OT8 GPIO_OTYPER_OT8_Msk +#define GPIO_OTYPER_OT9_Pos (9U) +#define GPIO_OTYPER_OT9_Msk (0x1UL << GPIO_OTYPER_OT9_Pos) /*!< 0x00000200 */ +#define GPIO_OTYPER_OT9 GPIO_OTYPER_OT9_Msk +#define GPIO_OTYPER_OT10_Pos (10U) +#define GPIO_OTYPER_OT10_Msk (0x1UL << GPIO_OTYPER_OT10_Pos) /*!< 0x00000400 */ +#define GPIO_OTYPER_OT10 GPIO_OTYPER_OT10_Msk +#define GPIO_OTYPER_OT11_Pos (11U) +#define GPIO_OTYPER_OT11_Msk (0x1UL << GPIO_OTYPER_OT11_Pos) /*!< 0x00000800 */ +#define GPIO_OTYPER_OT11 GPIO_OTYPER_OT11_Msk +#define GPIO_OTYPER_OT12_Pos (12U) +#define GPIO_OTYPER_OT12_Msk (0x1UL << GPIO_OTYPER_OT12_Pos) /*!< 0x00001000 */ +#define GPIO_OTYPER_OT12 GPIO_OTYPER_OT12_Msk +#define GPIO_OTYPER_OT13_Pos (13U) +#define GPIO_OTYPER_OT13_Msk (0x1UL << GPIO_OTYPER_OT13_Pos) /*!< 0x00002000 */ +#define GPIO_OTYPER_OT13 GPIO_OTYPER_OT13_Msk +#define GPIO_OTYPER_OT14_Pos (14U) +#define GPIO_OTYPER_OT14_Msk (0x1UL << GPIO_OTYPER_OT14_Pos) /*!< 0x00004000 */ +#define GPIO_OTYPER_OT14 GPIO_OTYPER_OT14_Msk +#define GPIO_OTYPER_OT15_Pos (15U) +#define GPIO_OTYPER_OT15_Msk (0x1UL << GPIO_OTYPER_OT15_Pos) /*!< 0x00008000 */ +#define GPIO_OTYPER_OT15 GPIO_OTYPER_OT15_Msk + +/* Legacy defines */ +#define GPIO_OTYPER_OT_0 GPIO_OTYPER_OT0 +#define GPIO_OTYPER_OT_1 GPIO_OTYPER_OT1 +#define GPIO_OTYPER_OT_2 GPIO_OTYPER_OT2 +#define GPIO_OTYPER_OT_3 GPIO_OTYPER_OT3 +#define GPIO_OTYPER_OT_4 GPIO_OTYPER_OT4 +#define GPIO_OTYPER_OT_5 GPIO_OTYPER_OT5 +#define GPIO_OTYPER_OT_6 GPIO_OTYPER_OT6 +#define GPIO_OTYPER_OT_7 GPIO_OTYPER_OT7 +#define GPIO_OTYPER_OT_8 GPIO_OTYPER_OT8 +#define GPIO_OTYPER_OT_9 GPIO_OTYPER_OT9 +#define GPIO_OTYPER_OT_10 GPIO_OTYPER_OT10 +#define GPIO_OTYPER_OT_11 GPIO_OTYPER_OT11 +#define GPIO_OTYPER_OT_12 GPIO_OTYPER_OT12 +#define GPIO_OTYPER_OT_13 GPIO_OTYPER_OT13 +#define GPIO_OTYPER_OT_14 GPIO_OTYPER_OT14 +#define GPIO_OTYPER_OT_15 GPIO_OTYPER_OT15 + +/****************** Bits definition for GPIO_OSPEEDR register ***************/ +#define GPIO_OSPEEDR_OSPEED0_Pos (0U) +#define GPIO_OSPEEDR_OSPEED0_Msk (0x3UL << GPIO_OSPEEDR_OSPEED0_Pos) /*!< 0x00000003 */ +#define GPIO_OSPEEDR_OSPEED0 GPIO_OSPEEDR_OSPEED0_Msk +#define GPIO_OSPEEDR_OSPEED0_0 (0x1UL << GPIO_OSPEEDR_OSPEED0_Pos) /*!< 0x00000001 */ +#define GPIO_OSPEEDR_OSPEED0_1 (0x2UL << GPIO_OSPEEDR_OSPEED0_Pos) /*!< 0x00000002 */ +#define GPIO_OSPEEDR_OSPEED1_Pos (2U) +#define GPIO_OSPEEDR_OSPEED1_Msk (0x3UL << GPIO_OSPEEDR_OSPEED1_Pos) /*!< 0x0000000C */ +#define GPIO_OSPEEDR_OSPEED1 GPIO_OSPEEDR_OSPEED1_Msk +#define GPIO_OSPEEDR_OSPEED1_0 (0x1UL << GPIO_OSPEEDR_OSPEED1_Pos) /*!< 0x00000004 */ +#define GPIO_OSPEEDR_OSPEED1_1 (0x2UL << GPIO_OSPEEDR_OSPEED1_Pos) /*!< 0x00000008 */ +#define GPIO_OSPEEDR_OSPEED2_Pos (4U) +#define GPIO_OSPEEDR_OSPEED2_Msk (0x3UL << GPIO_OSPEEDR_OSPEED2_Pos) /*!< 0x00000030 */ +#define GPIO_OSPEEDR_OSPEED2 GPIO_OSPEEDR_OSPEED2_Msk +#define GPIO_OSPEEDR_OSPEED2_0 (0x1UL << GPIO_OSPEEDR_OSPEED2_Pos) /*!< 0x00000010 */ +#define GPIO_OSPEEDR_OSPEED2_1 (0x2UL << GPIO_OSPEEDR_OSPEED2_Pos) /*!< 0x00000020 */ +#define GPIO_OSPEEDR_OSPEED3_Pos (6U) +#define GPIO_OSPEEDR_OSPEED3_Msk (0x3UL << GPIO_OSPEEDR_OSPEED3_Pos) /*!< 0x000000C0 */ +#define GPIO_OSPEEDR_OSPEED3 GPIO_OSPEEDR_OSPEED3_Msk +#define GPIO_OSPEEDR_OSPEED3_0 (0x1UL << GPIO_OSPEEDR_OSPEED3_Pos) /*!< 0x00000040 */ +#define GPIO_OSPEEDR_OSPEED3_1 (0x2UL << GPIO_OSPEEDR_OSPEED3_Pos) /*!< 0x00000080 */ +#define GPIO_OSPEEDR_OSPEED4_Pos (8U) +#define GPIO_OSPEEDR_OSPEED4_Msk (0x3UL << GPIO_OSPEEDR_OSPEED4_Pos) /*!< 0x00000300 */ +#define GPIO_OSPEEDR_OSPEED4 GPIO_OSPEEDR_OSPEED4_Msk +#define GPIO_OSPEEDR_OSPEED4_0 (0x1UL << GPIO_OSPEEDR_OSPEED4_Pos) /*!< 0x00000100 */ +#define GPIO_OSPEEDR_OSPEED4_1 (0x2UL << GPIO_OSPEEDR_OSPEED4_Pos) /*!< 0x00000200 */ +#define GPIO_OSPEEDR_OSPEED5_Pos (10U) +#define GPIO_OSPEEDR_OSPEED5_Msk (0x3UL << GPIO_OSPEEDR_OSPEED5_Pos) /*!< 0x00000C00 */ +#define GPIO_OSPEEDR_OSPEED5 GPIO_OSPEEDR_OSPEED5_Msk +#define GPIO_OSPEEDR_OSPEED5_0 (0x1UL << GPIO_OSPEEDR_OSPEED5_Pos) /*!< 0x00000400 */ +#define GPIO_OSPEEDR_OSPEED5_1 (0x2UL << GPIO_OSPEEDR_OSPEED5_Pos) /*!< 0x00000800 */ +#define GPIO_OSPEEDR_OSPEED6_Pos (12U) +#define GPIO_OSPEEDR_OSPEED6_Msk (0x3UL << GPIO_OSPEEDR_OSPEED6_Pos) /*!< 0x00003000 */ +#define GPIO_OSPEEDR_OSPEED6 GPIO_OSPEEDR_OSPEED6_Msk +#define GPIO_OSPEEDR_OSPEED6_0 (0x1UL << GPIO_OSPEEDR_OSPEED6_Pos) /*!< 0x00001000 */ +#define GPIO_OSPEEDR_OSPEED6_1 (0x2UL << GPIO_OSPEEDR_OSPEED6_Pos) /*!< 0x00002000 */ +#define GPIO_OSPEEDR_OSPEED7_Pos (14U) +#define GPIO_OSPEEDR_OSPEED7_Msk (0x3UL << GPIO_OSPEEDR_OSPEED7_Pos) /*!< 0x0000C000 */ +#define GPIO_OSPEEDR_OSPEED7 GPIO_OSPEEDR_OSPEED7_Msk +#define GPIO_OSPEEDR_OSPEED7_0 (0x1UL << GPIO_OSPEEDR_OSPEED7_Pos) /*!< 0x00004000 */ +#define GPIO_OSPEEDR_OSPEED7_1 (0x2UL << GPIO_OSPEEDR_OSPEED7_Pos) /*!< 0x00008000 */ +#define GPIO_OSPEEDR_OSPEED8_Pos (16U) +#define GPIO_OSPEEDR_OSPEED8_Msk (0x3UL << GPIO_OSPEEDR_OSPEED8_Pos) /*!< 0x00030000 */ +#define GPIO_OSPEEDR_OSPEED8 GPIO_OSPEEDR_OSPEED8_Msk +#define GPIO_OSPEEDR_OSPEED8_0 (0x1UL << GPIO_OSPEEDR_OSPEED8_Pos) /*!< 0x00010000 */ +#define GPIO_OSPEEDR_OSPEED8_1 (0x2UL << GPIO_OSPEEDR_OSPEED8_Pos) /*!< 0x00020000 */ +#define GPIO_OSPEEDR_OSPEED9_Pos (18U) +#define GPIO_OSPEEDR_OSPEED9_Msk (0x3UL << GPIO_OSPEEDR_OSPEED9_Pos) /*!< 0x000C0000 */ +#define GPIO_OSPEEDR_OSPEED9 GPIO_OSPEEDR_OSPEED9_Msk +#define GPIO_OSPEEDR_OSPEED9_0 (0x1UL << GPIO_OSPEEDR_OSPEED9_Pos) /*!< 0x00040000 */ +#define GPIO_OSPEEDR_OSPEED9_1 (0x2UL << GPIO_OSPEEDR_OSPEED9_Pos) /*!< 0x00080000 */ +#define GPIO_OSPEEDR_OSPEED10_Pos (20U) +#define GPIO_OSPEEDR_OSPEED10_Msk (0x3UL << GPIO_OSPEEDR_OSPEED10_Pos) /*!< 0x00300000 */ +#define GPIO_OSPEEDR_OSPEED10 GPIO_OSPEEDR_OSPEED10_Msk +#define GPIO_OSPEEDR_OSPEED10_0 (0x1UL << GPIO_OSPEEDR_OSPEED10_Pos) /*!< 0x00100000 */ +#define GPIO_OSPEEDR_OSPEED10_1 (0x2UL << GPIO_OSPEEDR_OSPEED10_Pos) /*!< 0x00200000 */ +#define GPIO_OSPEEDR_OSPEED11_Pos (22U) +#define GPIO_OSPEEDR_OSPEED11_Msk (0x3UL << GPIO_OSPEEDR_OSPEED11_Pos) /*!< 0x00C00000 */ +#define GPIO_OSPEEDR_OSPEED11 GPIO_OSPEEDR_OSPEED11_Msk +#define GPIO_OSPEEDR_OSPEED11_0 (0x1UL << GPIO_OSPEEDR_OSPEED11_Pos) /*!< 0x00400000 */ +#define GPIO_OSPEEDR_OSPEED11_1 (0x2UL << GPIO_OSPEEDR_OSPEED11_Pos) /*!< 0x00800000 */ +#define GPIO_OSPEEDR_OSPEED12_Pos (24U) +#define GPIO_OSPEEDR_OSPEED12_Msk (0x3UL << GPIO_OSPEEDR_OSPEED12_Pos) /*!< 0x03000000 */ +#define GPIO_OSPEEDR_OSPEED12 GPIO_OSPEEDR_OSPEED12_Msk +#define GPIO_OSPEEDR_OSPEED12_0 (0x1UL << GPIO_OSPEEDR_OSPEED12_Pos) /*!< 0x01000000 */ +#define GPIO_OSPEEDR_OSPEED12_1 (0x2UL << GPIO_OSPEEDR_OSPEED12_Pos) /*!< 0x02000000 */ +#define GPIO_OSPEEDR_OSPEED13_Pos (26U) +#define GPIO_OSPEEDR_OSPEED13_Msk (0x3UL << GPIO_OSPEEDR_OSPEED13_Pos) /*!< 0x0C000000 */ +#define GPIO_OSPEEDR_OSPEED13 GPIO_OSPEEDR_OSPEED13_Msk +#define GPIO_OSPEEDR_OSPEED13_0 (0x1UL << GPIO_OSPEEDR_OSPEED13_Pos) /*!< 0x04000000 */ +#define GPIO_OSPEEDR_OSPEED13_1 (0x2UL << GPIO_OSPEEDR_OSPEED13_Pos) /*!< 0x08000000 */ +#define GPIO_OSPEEDR_OSPEED14_Pos (28U) +#define GPIO_OSPEEDR_OSPEED14_Msk (0x3UL << GPIO_OSPEEDR_OSPEED14_Pos) /*!< 0x30000000 */ +#define GPIO_OSPEEDR_OSPEED14 GPIO_OSPEEDR_OSPEED14_Msk +#define GPIO_OSPEEDR_OSPEED14_0 (0x1UL << GPIO_OSPEEDR_OSPEED14_Pos) /*!< 0x10000000 */ +#define GPIO_OSPEEDR_OSPEED14_1 (0x2UL << GPIO_OSPEEDR_OSPEED14_Pos) /*!< 0x20000000 */ +#define GPIO_OSPEEDR_OSPEED15_Pos (30U) +#define GPIO_OSPEEDR_OSPEED15_Msk (0x3UL << GPIO_OSPEEDR_OSPEED15_Pos) /*!< 0xC0000000 */ +#define GPIO_OSPEEDR_OSPEED15 GPIO_OSPEEDR_OSPEED15_Msk +#define GPIO_OSPEEDR_OSPEED15_0 (0x1UL << GPIO_OSPEEDR_OSPEED15_Pos) /*!< 0x40000000 */ +#define GPIO_OSPEEDR_OSPEED15_1 (0x2UL << GPIO_OSPEEDR_OSPEED15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_OSPEEDER_OSPEEDR0 GPIO_OSPEEDR_OSPEED0 +#define GPIO_OSPEEDER_OSPEEDR0_0 GPIO_OSPEEDR_OSPEED0_0 +#define GPIO_OSPEEDER_OSPEEDR0_1 GPIO_OSPEEDR_OSPEED0_1 +#define GPIO_OSPEEDER_OSPEEDR1 GPIO_OSPEEDR_OSPEED1 +#define GPIO_OSPEEDER_OSPEEDR1_0 GPIO_OSPEEDR_OSPEED1_0 +#define GPIO_OSPEEDER_OSPEEDR1_1 GPIO_OSPEEDR_OSPEED1_1 +#define GPIO_OSPEEDER_OSPEEDR2 GPIO_OSPEEDR_OSPEED2 +#define GPIO_OSPEEDER_OSPEEDR2_0 GPIO_OSPEEDR_OSPEED2_0 +#define GPIO_OSPEEDER_OSPEEDR2_1 GPIO_OSPEEDR_OSPEED2_1 +#define GPIO_OSPEEDER_OSPEEDR3 GPIO_OSPEEDR_OSPEED3 +#define GPIO_OSPEEDER_OSPEEDR3_0 GPIO_OSPEEDR_OSPEED3_0 +#define GPIO_OSPEEDER_OSPEEDR3_1 GPIO_OSPEEDR_OSPEED3_1 +#define GPIO_OSPEEDER_OSPEEDR4 GPIO_OSPEEDR_OSPEED4 +#define GPIO_OSPEEDER_OSPEEDR4_0 GPIO_OSPEEDR_OSPEED4_0 +#define GPIO_OSPEEDER_OSPEEDR4_1 GPIO_OSPEEDR_OSPEED4_1 +#define GPIO_OSPEEDER_OSPEEDR5 GPIO_OSPEEDR_OSPEED5 +#define GPIO_OSPEEDER_OSPEEDR5_0 GPIO_OSPEEDR_OSPEED5_0 +#define GPIO_OSPEEDER_OSPEEDR5_1 GPIO_OSPEEDR_OSPEED5_1 +#define GPIO_OSPEEDER_OSPEEDR6 GPIO_OSPEEDR_OSPEED6 +#define GPIO_OSPEEDER_OSPEEDR6_0 GPIO_OSPEEDR_OSPEED6_0 +#define GPIO_OSPEEDER_OSPEEDR6_1 GPIO_OSPEEDR_OSPEED6_1 +#define GPIO_OSPEEDER_OSPEEDR7 GPIO_OSPEEDR_OSPEED7 +#define GPIO_OSPEEDER_OSPEEDR7_0 GPIO_OSPEEDR_OSPEED7_0 +#define GPIO_OSPEEDER_OSPEEDR7_1 GPIO_OSPEEDR_OSPEED7_1 +#define GPIO_OSPEEDER_OSPEEDR8 GPIO_OSPEEDR_OSPEED8 +#define GPIO_OSPEEDER_OSPEEDR8_0 GPIO_OSPEEDR_OSPEED8_0 +#define GPIO_OSPEEDER_OSPEEDR8_1 GPIO_OSPEEDR_OSPEED8_1 +#define GPIO_OSPEEDER_OSPEEDR9 GPIO_OSPEEDR_OSPEED9 +#define GPIO_OSPEEDER_OSPEEDR9_0 GPIO_OSPEEDR_OSPEED9_0 +#define GPIO_OSPEEDER_OSPEEDR9_1 GPIO_OSPEEDR_OSPEED9_1 +#define GPIO_OSPEEDER_OSPEEDR10 GPIO_OSPEEDR_OSPEED10 +#define GPIO_OSPEEDER_OSPEEDR10_0 GPIO_OSPEEDR_OSPEED10_0 +#define GPIO_OSPEEDER_OSPEEDR10_1 GPIO_OSPEEDR_OSPEED10_1 +#define GPIO_OSPEEDER_OSPEEDR11 GPIO_OSPEEDR_OSPEED11 +#define GPIO_OSPEEDER_OSPEEDR11_0 GPIO_OSPEEDR_OSPEED11_0 +#define GPIO_OSPEEDER_OSPEEDR11_1 GPIO_OSPEEDR_OSPEED11_1 +#define GPIO_OSPEEDER_OSPEEDR12 GPIO_OSPEEDR_OSPEED12 +#define GPIO_OSPEEDER_OSPEEDR12_0 GPIO_OSPEEDR_OSPEED12_0 +#define GPIO_OSPEEDER_OSPEEDR12_1 GPIO_OSPEEDR_OSPEED12_1 +#define GPIO_OSPEEDER_OSPEEDR13 GPIO_OSPEEDR_OSPEED13 +#define GPIO_OSPEEDER_OSPEEDR13_0 GPIO_OSPEEDR_OSPEED13_0 +#define GPIO_OSPEEDER_OSPEEDR13_1 GPIO_OSPEEDR_OSPEED13_1 +#define GPIO_OSPEEDER_OSPEEDR14 GPIO_OSPEEDR_OSPEED14 +#define GPIO_OSPEEDER_OSPEEDR14_0 GPIO_OSPEEDR_OSPEED14_0 +#define GPIO_OSPEEDER_OSPEEDR14_1 GPIO_OSPEEDR_OSPEED14_1 +#define GPIO_OSPEEDER_OSPEEDR15 GPIO_OSPEEDR_OSPEED15 +#define GPIO_OSPEEDER_OSPEEDR15_0 GPIO_OSPEEDR_OSPEED15_0 +#define GPIO_OSPEEDER_OSPEEDR15_1 GPIO_OSPEEDR_OSPEED15_1 + +/****************** Bits definition for GPIO_PUPDR register *****************/ +#define GPIO_PUPDR_PUPD0_Pos (0U) +#define GPIO_PUPDR_PUPD0_Msk (0x3UL << GPIO_PUPDR_PUPD0_Pos) /*!< 0x00000003 */ +#define GPIO_PUPDR_PUPD0 GPIO_PUPDR_PUPD0_Msk +#define GPIO_PUPDR_PUPD0_0 (0x1UL << GPIO_PUPDR_PUPD0_Pos) /*!< 0x00000001 */ +#define GPIO_PUPDR_PUPD0_1 (0x2UL << GPIO_PUPDR_PUPD0_Pos) /*!< 0x00000002 */ +#define GPIO_PUPDR_PUPD1_Pos (2U) +#define GPIO_PUPDR_PUPD1_Msk (0x3UL << GPIO_PUPDR_PUPD1_Pos) /*!< 0x0000000C */ +#define GPIO_PUPDR_PUPD1 GPIO_PUPDR_PUPD1_Msk +#define GPIO_PUPDR_PUPD1_0 (0x1UL << GPIO_PUPDR_PUPD1_Pos) /*!< 0x00000004 */ +#define GPIO_PUPDR_PUPD1_1 (0x2UL << GPIO_PUPDR_PUPD1_Pos) /*!< 0x00000008 */ +#define GPIO_PUPDR_PUPD2_Pos (4U) +#define GPIO_PUPDR_PUPD2_Msk (0x3UL << GPIO_PUPDR_PUPD2_Pos) /*!< 0x00000030 */ +#define GPIO_PUPDR_PUPD2 GPIO_PUPDR_PUPD2_Msk +#define GPIO_PUPDR_PUPD2_0 (0x1UL << GPIO_PUPDR_PUPD2_Pos) /*!< 0x00000010 */ +#define GPIO_PUPDR_PUPD2_1 (0x2UL << GPIO_PUPDR_PUPD2_Pos) /*!< 0x00000020 */ +#define GPIO_PUPDR_PUPD3_Pos (6U) +#define GPIO_PUPDR_PUPD3_Msk (0x3UL << GPIO_PUPDR_PUPD3_Pos) /*!< 0x000000C0 */ +#define GPIO_PUPDR_PUPD3 GPIO_PUPDR_PUPD3_Msk +#define GPIO_PUPDR_PUPD3_0 (0x1UL << GPIO_PUPDR_PUPD3_Pos) /*!< 0x00000040 */ +#define GPIO_PUPDR_PUPD3_1 (0x2UL << GPIO_PUPDR_PUPD3_Pos) /*!< 0x00000080 */ +#define GPIO_PUPDR_PUPD4_Pos (8U) +#define GPIO_PUPDR_PUPD4_Msk (0x3UL << GPIO_PUPDR_PUPD4_Pos) /*!< 0x00000300 */ +#define GPIO_PUPDR_PUPD4 GPIO_PUPDR_PUPD4_Msk +#define GPIO_PUPDR_PUPD4_0 (0x1UL << GPIO_PUPDR_PUPD4_Pos) /*!< 0x00000100 */ +#define GPIO_PUPDR_PUPD4_1 (0x2UL << GPIO_PUPDR_PUPD4_Pos) /*!< 0x00000200 */ +#define GPIO_PUPDR_PUPD5_Pos (10U) +#define GPIO_PUPDR_PUPD5_Msk (0x3UL << GPIO_PUPDR_PUPD5_Pos) /*!< 0x00000C00 */ +#define GPIO_PUPDR_PUPD5 GPIO_PUPDR_PUPD5_Msk +#define GPIO_PUPDR_PUPD5_0 (0x1UL << GPIO_PUPDR_PUPD5_Pos) /*!< 0x00000400 */ +#define GPIO_PUPDR_PUPD5_1 (0x2UL << GPIO_PUPDR_PUPD5_Pos) /*!< 0x00000800 */ +#define GPIO_PUPDR_PUPD6_Pos (12U) +#define GPIO_PUPDR_PUPD6_Msk (0x3UL << GPIO_PUPDR_PUPD6_Pos) /*!< 0x00003000 */ +#define GPIO_PUPDR_PUPD6 GPIO_PUPDR_PUPD6_Msk +#define GPIO_PUPDR_PUPD6_0 (0x1UL << GPIO_PUPDR_PUPD6_Pos) /*!< 0x00001000 */ +#define GPIO_PUPDR_PUPD6_1 (0x2UL << GPIO_PUPDR_PUPD6_Pos) /*!< 0x00002000 */ +#define GPIO_PUPDR_PUPD7_Pos (14U) +#define GPIO_PUPDR_PUPD7_Msk (0x3UL << GPIO_PUPDR_PUPD7_Pos) /*!< 0x0000C000 */ +#define GPIO_PUPDR_PUPD7 GPIO_PUPDR_PUPD7_Msk +#define GPIO_PUPDR_PUPD7_0 (0x1UL << GPIO_PUPDR_PUPD7_Pos) /*!< 0x00004000 */ +#define GPIO_PUPDR_PUPD7_1 (0x2UL << GPIO_PUPDR_PUPD7_Pos) /*!< 0x00008000 */ +#define GPIO_PUPDR_PUPD8_Pos (16U) +#define GPIO_PUPDR_PUPD8_Msk (0x3UL << GPIO_PUPDR_PUPD8_Pos) /*!< 0x00030000 */ +#define GPIO_PUPDR_PUPD8 GPIO_PUPDR_PUPD8_Msk +#define GPIO_PUPDR_PUPD8_0 (0x1UL << GPIO_PUPDR_PUPD8_Pos) /*!< 0x00010000 */ +#define GPIO_PUPDR_PUPD8_1 (0x2UL << GPIO_PUPDR_PUPD8_Pos) /*!< 0x00020000 */ +#define GPIO_PUPDR_PUPD9_Pos (18U) +#define GPIO_PUPDR_PUPD9_Msk (0x3UL << GPIO_PUPDR_PUPD9_Pos) /*!< 0x000C0000 */ +#define GPIO_PUPDR_PUPD9 GPIO_PUPDR_PUPD9_Msk +#define GPIO_PUPDR_PUPD9_0 (0x1UL << GPIO_PUPDR_PUPD9_Pos) /*!< 0x00040000 */ +#define GPIO_PUPDR_PUPD9_1 (0x2UL << GPIO_PUPDR_PUPD9_Pos) /*!< 0x00080000 */ +#define GPIO_PUPDR_PUPD10_Pos (20U) +#define GPIO_PUPDR_PUPD10_Msk (0x3UL << GPIO_PUPDR_PUPD10_Pos) /*!< 0x00300000 */ +#define GPIO_PUPDR_PUPD10 GPIO_PUPDR_PUPD10_Msk +#define GPIO_PUPDR_PUPD10_0 (0x1UL << GPIO_PUPDR_PUPD10_Pos) /*!< 0x00100000 */ +#define GPIO_PUPDR_PUPD10_1 (0x2UL << GPIO_PUPDR_PUPD10_Pos) /*!< 0x00200000 */ +#define GPIO_PUPDR_PUPD11_Pos (22U) +#define GPIO_PUPDR_PUPD11_Msk (0x3UL << GPIO_PUPDR_PUPD11_Pos) /*!< 0x00C00000 */ +#define GPIO_PUPDR_PUPD11 GPIO_PUPDR_PUPD11_Msk +#define GPIO_PUPDR_PUPD11_0 (0x1UL << GPIO_PUPDR_PUPD11_Pos) /*!< 0x00400000 */ +#define GPIO_PUPDR_PUPD11_1 (0x2UL << GPIO_PUPDR_PUPD11_Pos) /*!< 0x00800000 */ +#define GPIO_PUPDR_PUPD12_Pos (24U) +#define GPIO_PUPDR_PUPD12_Msk (0x3UL << GPIO_PUPDR_PUPD12_Pos) /*!< 0x03000000 */ +#define GPIO_PUPDR_PUPD12 GPIO_PUPDR_PUPD12_Msk +#define GPIO_PUPDR_PUPD12_0 (0x1UL << GPIO_PUPDR_PUPD12_Pos) /*!< 0x01000000 */ +#define GPIO_PUPDR_PUPD12_1 (0x2UL << GPIO_PUPDR_PUPD12_Pos) /*!< 0x02000000 */ +#define GPIO_PUPDR_PUPD13_Pos (26U) +#define GPIO_PUPDR_PUPD13_Msk (0x3UL << GPIO_PUPDR_PUPD13_Pos) /*!< 0x0C000000 */ +#define GPIO_PUPDR_PUPD13 GPIO_PUPDR_PUPD13_Msk +#define GPIO_PUPDR_PUPD13_0 (0x1UL << GPIO_PUPDR_PUPD13_Pos) /*!< 0x04000000 */ +#define GPIO_PUPDR_PUPD13_1 (0x2UL << GPIO_PUPDR_PUPD13_Pos) /*!< 0x08000000 */ +#define GPIO_PUPDR_PUPD14_Pos (28U) +#define GPIO_PUPDR_PUPD14_Msk (0x3UL << GPIO_PUPDR_PUPD14_Pos) /*!< 0x30000000 */ +#define GPIO_PUPDR_PUPD14 GPIO_PUPDR_PUPD14_Msk +#define GPIO_PUPDR_PUPD14_0 (0x1UL << GPIO_PUPDR_PUPD14_Pos) /*!< 0x10000000 */ +#define GPIO_PUPDR_PUPD14_1 (0x2UL << GPIO_PUPDR_PUPD14_Pos) /*!< 0x20000000 */ +#define GPIO_PUPDR_PUPD15_Pos (30U) +#define GPIO_PUPDR_PUPD15_Msk (0x3UL << GPIO_PUPDR_PUPD15_Pos) /*!< 0xC0000000 */ +#define GPIO_PUPDR_PUPD15 GPIO_PUPDR_PUPD15_Msk +#define GPIO_PUPDR_PUPD15_0 (0x1UL << GPIO_PUPDR_PUPD15_Pos) /*!< 0x40000000 */ +#define GPIO_PUPDR_PUPD15_1 (0x2UL << GPIO_PUPDR_PUPD15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_PUPDR_PUPDR0 GPIO_PUPDR_PUPD0 +#define GPIO_PUPDR_PUPDR0_0 GPIO_PUPDR_PUPD0_0 +#define GPIO_PUPDR_PUPDR0_1 GPIO_PUPDR_PUPD0_1 +#define GPIO_PUPDR_PUPDR1 GPIO_PUPDR_PUPD1 +#define GPIO_PUPDR_PUPDR1_0 GPIO_PUPDR_PUPD1_0 +#define GPIO_PUPDR_PUPDR1_1 GPIO_PUPDR_PUPD1_1 +#define GPIO_PUPDR_PUPDR2 GPIO_PUPDR_PUPD2 +#define GPIO_PUPDR_PUPDR2_0 GPIO_PUPDR_PUPD2_0 +#define GPIO_PUPDR_PUPDR2_1 GPIO_PUPDR_PUPD2_1 +#define GPIO_PUPDR_PUPDR3 GPIO_PUPDR_PUPD3 +#define GPIO_PUPDR_PUPDR3_0 GPIO_PUPDR_PUPD3_0 +#define GPIO_PUPDR_PUPDR3_1 GPIO_PUPDR_PUPD3_1 +#define GPIO_PUPDR_PUPDR4 GPIO_PUPDR_PUPD4 +#define GPIO_PUPDR_PUPDR4_0 GPIO_PUPDR_PUPD4_0 +#define GPIO_PUPDR_PUPDR4_1 GPIO_PUPDR_PUPD4_1 +#define GPIO_PUPDR_PUPDR5 GPIO_PUPDR_PUPD5 +#define GPIO_PUPDR_PUPDR5_0 GPIO_PUPDR_PUPD5_0 +#define GPIO_PUPDR_PUPDR5_1 GPIO_PUPDR_PUPD5_1 +#define GPIO_PUPDR_PUPDR6 GPIO_PUPDR_PUPD6 +#define GPIO_PUPDR_PUPDR6_0 GPIO_PUPDR_PUPD6_0 +#define GPIO_PUPDR_PUPDR6_1 GPIO_PUPDR_PUPD6_1 +#define GPIO_PUPDR_PUPDR7 GPIO_PUPDR_PUPD7 +#define GPIO_PUPDR_PUPDR7_0 GPIO_PUPDR_PUPD7_0 +#define GPIO_PUPDR_PUPDR7_1 GPIO_PUPDR_PUPD7_1 +#define GPIO_PUPDR_PUPDR8 GPIO_PUPDR_PUPD8 +#define GPIO_PUPDR_PUPDR8_0 GPIO_PUPDR_PUPD8_0 +#define GPIO_PUPDR_PUPDR8_1 GPIO_PUPDR_PUPD8_1 +#define GPIO_PUPDR_PUPDR9 GPIO_PUPDR_PUPD9 +#define GPIO_PUPDR_PUPDR9_0 GPIO_PUPDR_PUPD9_0 +#define GPIO_PUPDR_PUPDR9_1 GPIO_PUPDR_PUPD9_1 +#define GPIO_PUPDR_PUPDR10 GPIO_PUPDR_PUPD10 +#define GPIO_PUPDR_PUPDR10_0 GPIO_PUPDR_PUPD10_0 +#define GPIO_PUPDR_PUPDR10_1 GPIO_PUPDR_PUPD10_1 +#define GPIO_PUPDR_PUPDR11 GPIO_PUPDR_PUPD11 +#define GPIO_PUPDR_PUPDR11_0 GPIO_PUPDR_PUPD11_0 +#define GPIO_PUPDR_PUPDR11_1 GPIO_PUPDR_PUPD11_1 +#define GPIO_PUPDR_PUPDR12 GPIO_PUPDR_PUPD12 +#define GPIO_PUPDR_PUPDR12_0 GPIO_PUPDR_PUPD12_0 +#define GPIO_PUPDR_PUPDR12_1 GPIO_PUPDR_PUPD12_1 +#define GPIO_PUPDR_PUPDR13 GPIO_PUPDR_PUPD13 +#define GPIO_PUPDR_PUPDR13_0 GPIO_PUPDR_PUPD13_0 +#define GPIO_PUPDR_PUPDR13_1 GPIO_PUPDR_PUPD13_1 +#define GPIO_PUPDR_PUPDR14 GPIO_PUPDR_PUPD14 +#define GPIO_PUPDR_PUPDR14_0 GPIO_PUPDR_PUPD14_0 +#define GPIO_PUPDR_PUPDR14_1 GPIO_PUPDR_PUPD14_1 +#define GPIO_PUPDR_PUPDR15 GPIO_PUPDR_PUPD15 +#define GPIO_PUPDR_PUPDR15_0 GPIO_PUPDR_PUPD15_0 +#define GPIO_PUPDR_PUPDR15_1 GPIO_PUPDR_PUPD15_1 + +/****************** Bits definition for GPIO_IDR register *******************/ +#define GPIO_IDR_ID0_Pos (0U) +#define GPIO_IDR_ID0_Msk (0x1UL << GPIO_IDR_ID0_Pos) /*!< 0x00000001 */ +#define GPIO_IDR_ID0 GPIO_IDR_ID0_Msk +#define GPIO_IDR_ID1_Pos (1U) +#define GPIO_IDR_ID1_Msk (0x1UL << GPIO_IDR_ID1_Pos) /*!< 0x00000002 */ +#define GPIO_IDR_ID1 GPIO_IDR_ID1_Msk +#define GPIO_IDR_ID2_Pos (2U) +#define GPIO_IDR_ID2_Msk (0x1UL << GPIO_IDR_ID2_Pos) /*!< 0x00000004 */ +#define GPIO_IDR_ID2 GPIO_IDR_ID2_Msk +#define GPIO_IDR_ID3_Pos (3U) +#define GPIO_IDR_ID3_Msk (0x1UL << GPIO_IDR_ID3_Pos) /*!< 0x00000008 */ +#define GPIO_IDR_ID3 GPIO_IDR_ID3_Msk +#define GPIO_IDR_ID4_Pos (4U) +#define GPIO_IDR_ID4_Msk (0x1UL << GPIO_IDR_ID4_Pos) /*!< 0x00000010 */ +#define GPIO_IDR_ID4 GPIO_IDR_ID4_Msk +#define GPIO_IDR_ID5_Pos (5U) +#define GPIO_IDR_ID5_Msk (0x1UL << GPIO_IDR_ID5_Pos) /*!< 0x00000020 */ +#define GPIO_IDR_ID5 GPIO_IDR_ID5_Msk +#define GPIO_IDR_ID6_Pos (6U) +#define GPIO_IDR_ID6_Msk (0x1UL << GPIO_IDR_ID6_Pos) /*!< 0x00000040 */ +#define GPIO_IDR_ID6 GPIO_IDR_ID6_Msk +#define GPIO_IDR_ID7_Pos (7U) +#define GPIO_IDR_ID7_Msk (0x1UL << GPIO_IDR_ID7_Pos) /*!< 0x00000080 */ +#define GPIO_IDR_ID7 GPIO_IDR_ID7_Msk +#define GPIO_IDR_ID8_Pos (8U) +#define GPIO_IDR_ID8_Msk (0x1UL << GPIO_IDR_ID8_Pos) /*!< 0x00000100 */ +#define GPIO_IDR_ID8 GPIO_IDR_ID8_Msk +#define GPIO_IDR_ID9_Pos (9U) +#define GPIO_IDR_ID9_Msk (0x1UL << GPIO_IDR_ID9_Pos) /*!< 0x00000200 */ +#define GPIO_IDR_ID9 GPIO_IDR_ID9_Msk +#define GPIO_IDR_ID10_Pos (10U) +#define GPIO_IDR_ID10_Msk (0x1UL << GPIO_IDR_ID10_Pos) /*!< 0x00000400 */ +#define GPIO_IDR_ID10 GPIO_IDR_ID10_Msk +#define GPIO_IDR_ID11_Pos (11U) +#define GPIO_IDR_ID11_Msk (0x1UL << GPIO_IDR_ID11_Pos) /*!< 0x00000800 */ +#define GPIO_IDR_ID11 GPIO_IDR_ID11_Msk +#define GPIO_IDR_ID12_Pos (12U) +#define GPIO_IDR_ID12_Msk (0x1UL << GPIO_IDR_ID12_Pos) /*!< 0x00001000 */ +#define GPIO_IDR_ID12 GPIO_IDR_ID12_Msk +#define GPIO_IDR_ID13_Pos (13U) +#define GPIO_IDR_ID13_Msk (0x1UL << GPIO_IDR_ID13_Pos) /*!< 0x00002000 */ +#define GPIO_IDR_ID13 GPIO_IDR_ID13_Msk +#define GPIO_IDR_ID14_Pos (14U) +#define GPIO_IDR_ID14_Msk (0x1UL << GPIO_IDR_ID14_Pos) /*!< 0x00004000 */ +#define GPIO_IDR_ID14 GPIO_IDR_ID14_Msk +#define GPIO_IDR_ID15_Pos (15U) +#define GPIO_IDR_ID15_Msk (0x1UL << GPIO_IDR_ID15_Pos) /*!< 0x00008000 */ +#define GPIO_IDR_ID15 GPIO_IDR_ID15_Msk + +/* Legacy defines */ +#define GPIO_IDR_IDR_0 GPIO_IDR_ID0 +#define GPIO_IDR_IDR_1 GPIO_IDR_ID1 +#define GPIO_IDR_IDR_2 GPIO_IDR_ID2 +#define GPIO_IDR_IDR_3 GPIO_IDR_ID3 +#define GPIO_IDR_IDR_4 GPIO_IDR_ID4 +#define GPIO_IDR_IDR_5 GPIO_IDR_ID5 +#define GPIO_IDR_IDR_6 GPIO_IDR_ID6 +#define GPIO_IDR_IDR_7 GPIO_IDR_ID7 +#define GPIO_IDR_IDR_8 GPIO_IDR_ID8 +#define GPIO_IDR_IDR_9 GPIO_IDR_ID9 +#define GPIO_IDR_IDR_10 GPIO_IDR_ID10 +#define GPIO_IDR_IDR_11 GPIO_IDR_ID11 +#define GPIO_IDR_IDR_12 GPIO_IDR_ID12 +#define GPIO_IDR_IDR_13 GPIO_IDR_ID13 +#define GPIO_IDR_IDR_14 GPIO_IDR_ID14 +#define GPIO_IDR_IDR_15 GPIO_IDR_ID15 + +/* Old GPIO_IDR register bits definition, maintained for legacy purpose */ +#define GPIO_OTYPER_IDR_0 GPIO_IDR_ID0 +#define GPIO_OTYPER_IDR_1 GPIO_IDR_ID1 +#define GPIO_OTYPER_IDR_2 GPIO_IDR_ID2 +#define GPIO_OTYPER_IDR_3 GPIO_IDR_ID3 +#define GPIO_OTYPER_IDR_4 GPIO_IDR_ID4 +#define GPIO_OTYPER_IDR_5 GPIO_IDR_ID5 +#define GPIO_OTYPER_IDR_6 GPIO_IDR_ID6 +#define GPIO_OTYPER_IDR_7 GPIO_IDR_ID7 +#define GPIO_OTYPER_IDR_8 GPIO_IDR_ID8 +#define GPIO_OTYPER_IDR_9 GPIO_IDR_ID9 +#define GPIO_OTYPER_IDR_10 GPIO_IDR_ID10 +#define GPIO_OTYPER_IDR_11 GPIO_IDR_ID11 +#define GPIO_OTYPER_IDR_12 GPIO_IDR_ID12 +#define GPIO_OTYPER_IDR_13 GPIO_IDR_ID13 +#define GPIO_OTYPER_IDR_14 GPIO_IDR_ID14 +#define GPIO_OTYPER_IDR_15 GPIO_IDR_ID15 + +/****************** Bits definition for GPIO_ODR register *******************/ +#define GPIO_ODR_OD0_Pos (0U) +#define GPIO_ODR_OD0_Msk (0x1UL << GPIO_ODR_OD0_Pos) /*!< 0x00000001 */ +#define GPIO_ODR_OD0 GPIO_ODR_OD0_Msk +#define GPIO_ODR_OD1_Pos (1U) +#define GPIO_ODR_OD1_Msk (0x1UL << GPIO_ODR_OD1_Pos) /*!< 0x00000002 */ +#define GPIO_ODR_OD1 GPIO_ODR_OD1_Msk +#define GPIO_ODR_OD2_Pos (2U) +#define GPIO_ODR_OD2_Msk (0x1UL << GPIO_ODR_OD2_Pos) /*!< 0x00000004 */ +#define GPIO_ODR_OD2 GPIO_ODR_OD2_Msk +#define GPIO_ODR_OD3_Pos (3U) +#define GPIO_ODR_OD3_Msk (0x1UL << GPIO_ODR_OD3_Pos) /*!< 0x00000008 */ +#define GPIO_ODR_OD3 GPIO_ODR_OD3_Msk +#define GPIO_ODR_OD4_Pos (4U) +#define GPIO_ODR_OD4_Msk (0x1UL << GPIO_ODR_OD4_Pos) /*!< 0x00000010 */ +#define GPIO_ODR_OD4 GPIO_ODR_OD4_Msk +#define GPIO_ODR_OD5_Pos (5U) +#define GPIO_ODR_OD5_Msk (0x1UL << GPIO_ODR_OD5_Pos) /*!< 0x00000020 */ +#define GPIO_ODR_OD5 GPIO_ODR_OD5_Msk +#define GPIO_ODR_OD6_Pos (6U) +#define GPIO_ODR_OD6_Msk (0x1UL << GPIO_ODR_OD6_Pos) /*!< 0x00000040 */ +#define GPIO_ODR_OD6 GPIO_ODR_OD6_Msk +#define GPIO_ODR_OD7_Pos (7U) +#define GPIO_ODR_OD7_Msk (0x1UL << GPIO_ODR_OD7_Pos) /*!< 0x00000080 */ +#define GPIO_ODR_OD7 GPIO_ODR_OD7_Msk +#define GPIO_ODR_OD8_Pos (8U) +#define GPIO_ODR_OD8_Msk (0x1UL << GPIO_ODR_OD8_Pos) /*!< 0x00000100 */ +#define GPIO_ODR_OD8 GPIO_ODR_OD8_Msk +#define GPIO_ODR_OD9_Pos (9U) +#define GPIO_ODR_OD9_Msk (0x1UL << GPIO_ODR_OD9_Pos) /*!< 0x00000200 */ +#define GPIO_ODR_OD9 GPIO_ODR_OD9_Msk +#define GPIO_ODR_OD10_Pos (10U) +#define GPIO_ODR_OD10_Msk (0x1UL << GPIO_ODR_OD10_Pos) /*!< 0x00000400 */ +#define GPIO_ODR_OD10 GPIO_ODR_OD10_Msk +#define GPIO_ODR_OD11_Pos (11U) +#define GPIO_ODR_OD11_Msk (0x1UL << GPIO_ODR_OD11_Pos) /*!< 0x00000800 */ +#define GPIO_ODR_OD11 GPIO_ODR_OD11_Msk +#define GPIO_ODR_OD12_Pos (12U) +#define GPIO_ODR_OD12_Msk (0x1UL << GPIO_ODR_OD12_Pos) /*!< 0x00001000 */ +#define GPIO_ODR_OD12 GPIO_ODR_OD12_Msk +#define GPIO_ODR_OD13_Pos (13U) +#define GPIO_ODR_OD13_Msk (0x1UL << GPIO_ODR_OD13_Pos) /*!< 0x00002000 */ +#define GPIO_ODR_OD13 GPIO_ODR_OD13_Msk +#define GPIO_ODR_OD14_Pos (14U) +#define GPIO_ODR_OD14_Msk (0x1UL << GPIO_ODR_OD14_Pos) /*!< 0x00004000 */ +#define GPIO_ODR_OD14 GPIO_ODR_OD14_Msk +#define GPIO_ODR_OD15_Pos (15U) +#define GPIO_ODR_OD15_Msk (0x1UL << GPIO_ODR_OD15_Pos) /*!< 0x00008000 */ +#define GPIO_ODR_OD15 GPIO_ODR_OD15_Msk + +/* Legacy defines */ +#define GPIO_ODR_ODR_0 GPIO_ODR_OD0 +#define GPIO_ODR_ODR_1 GPIO_ODR_OD1 +#define GPIO_ODR_ODR_2 GPIO_ODR_OD2 +#define GPIO_ODR_ODR_3 GPIO_ODR_OD3 +#define GPIO_ODR_ODR_4 GPIO_ODR_OD4 +#define GPIO_ODR_ODR_5 GPIO_ODR_OD5 +#define GPIO_ODR_ODR_6 GPIO_ODR_OD6 +#define GPIO_ODR_ODR_7 GPIO_ODR_OD7 +#define GPIO_ODR_ODR_8 GPIO_ODR_OD8 +#define GPIO_ODR_ODR_9 GPIO_ODR_OD9 +#define GPIO_ODR_ODR_10 GPIO_ODR_OD10 +#define GPIO_ODR_ODR_11 GPIO_ODR_OD11 +#define GPIO_ODR_ODR_12 GPIO_ODR_OD12 +#define GPIO_ODR_ODR_13 GPIO_ODR_OD13 +#define GPIO_ODR_ODR_14 GPIO_ODR_OD14 +#define GPIO_ODR_ODR_15 GPIO_ODR_OD15 + +/* Old GPIO_ODR register bits definition, maintained for legacy purpose */ +#define GPIO_OTYPER_ODR_0 GPIO_ODR_OD0 +#define GPIO_OTYPER_ODR_1 GPIO_ODR_OD1 +#define GPIO_OTYPER_ODR_2 GPIO_ODR_OD2 +#define GPIO_OTYPER_ODR_3 GPIO_ODR_OD3 +#define GPIO_OTYPER_ODR_4 GPIO_ODR_OD4 +#define GPIO_OTYPER_ODR_5 GPIO_ODR_OD5 +#define GPIO_OTYPER_ODR_6 GPIO_ODR_OD6 +#define GPIO_OTYPER_ODR_7 GPIO_ODR_OD7 +#define GPIO_OTYPER_ODR_8 GPIO_ODR_OD8 +#define GPIO_OTYPER_ODR_9 GPIO_ODR_OD9 +#define GPIO_OTYPER_ODR_10 GPIO_ODR_OD10 +#define GPIO_OTYPER_ODR_11 GPIO_ODR_OD11 +#define GPIO_OTYPER_ODR_12 GPIO_ODR_OD12 +#define GPIO_OTYPER_ODR_13 GPIO_ODR_OD13 +#define GPIO_OTYPER_ODR_14 GPIO_ODR_OD14 +#define GPIO_OTYPER_ODR_15 GPIO_ODR_OD15 + +/****************** Bits definition for GPIO_BSRR register ******************/ +#define GPIO_BSRR_BS0_Pos (0U) +#define GPIO_BSRR_BS0_Msk (0x1UL << GPIO_BSRR_BS0_Pos) /*!< 0x00000001 */ +#define GPIO_BSRR_BS0 GPIO_BSRR_BS0_Msk +#define GPIO_BSRR_BS1_Pos (1U) +#define GPIO_BSRR_BS1_Msk (0x1UL << GPIO_BSRR_BS1_Pos) /*!< 0x00000002 */ +#define GPIO_BSRR_BS1 GPIO_BSRR_BS1_Msk +#define GPIO_BSRR_BS2_Pos (2U) +#define GPIO_BSRR_BS2_Msk (0x1UL << GPIO_BSRR_BS2_Pos) /*!< 0x00000004 */ +#define GPIO_BSRR_BS2 GPIO_BSRR_BS2_Msk +#define GPIO_BSRR_BS3_Pos (3U) +#define GPIO_BSRR_BS3_Msk (0x1UL << GPIO_BSRR_BS3_Pos) /*!< 0x00000008 */ +#define GPIO_BSRR_BS3 GPIO_BSRR_BS3_Msk +#define GPIO_BSRR_BS4_Pos (4U) +#define GPIO_BSRR_BS4_Msk (0x1UL << GPIO_BSRR_BS4_Pos) /*!< 0x00000010 */ +#define GPIO_BSRR_BS4 GPIO_BSRR_BS4_Msk +#define GPIO_BSRR_BS5_Pos (5U) +#define GPIO_BSRR_BS5_Msk (0x1UL << GPIO_BSRR_BS5_Pos) /*!< 0x00000020 */ +#define GPIO_BSRR_BS5 GPIO_BSRR_BS5_Msk +#define GPIO_BSRR_BS6_Pos (6U) +#define GPIO_BSRR_BS6_Msk (0x1UL << GPIO_BSRR_BS6_Pos) /*!< 0x00000040 */ +#define GPIO_BSRR_BS6 GPIO_BSRR_BS6_Msk +#define GPIO_BSRR_BS7_Pos (7U) +#define GPIO_BSRR_BS7_Msk (0x1UL << GPIO_BSRR_BS7_Pos) /*!< 0x00000080 */ +#define GPIO_BSRR_BS7 GPIO_BSRR_BS7_Msk +#define GPIO_BSRR_BS8_Pos (8U) +#define GPIO_BSRR_BS8_Msk (0x1UL << GPIO_BSRR_BS8_Pos) /*!< 0x00000100 */ +#define GPIO_BSRR_BS8 GPIO_BSRR_BS8_Msk +#define GPIO_BSRR_BS9_Pos (9U) +#define GPIO_BSRR_BS9_Msk (0x1UL << GPIO_BSRR_BS9_Pos) /*!< 0x00000200 */ +#define GPIO_BSRR_BS9 GPIO_BSRR_BS9_Msk +#define GPIO_BSRR_BS10_Pos (10U) +#define GPIO_BSRR_BS10_Msk (0x1UL << GPIO_BSRR_BS10_Pos) /*!< 0x00000400 */ +#define GPIO_BSRR_BS10 GPIO_BSRR_BS10_Msk +#define GPIO_BSRR_BS11_Pos (11U) +#define GPIO_BSRR_BS11_Msk (0x1UL << GPIO_BSRR_BS11_Pos) /*!< 0x00000800 */ +#define GPIO_BSRR_BS11 GPIO_BSRR_BS11_Msk +#define GPIO_BSRR_BS12_Pos (12U) +#define GPIO_BSRR_BS12_Msk (0x1UL << GPIO_BSRR_BS12_Pos) /*!< 0x00001000 */ +#define GPIO_BSRR_BS12 GPIO_BSRR_BS12_Msk +#define GPIO_BSRR_BS13_Pos (13U) +#define GPIO_BSRR_BS13_Msk (0x1UL << GPIO_BSRR_BS13_Pos) /*!< 0x00002000 */ +#define GPIO_BSRR_BS13 GPIO_BSRR_BS13_Msk +#define GPIO_BSRR_BS14_Pos (14U) +#define GPIO_BSRR_BS14_Msk (0x1UL << GPIO_BSRR_BS14_Pos) /*!< 0x00004000 */ +#define GPIO_BSRR_BS14 GPIO_BSRR_BS14_Msk +#define GPIO_BSRR_BS15_Pos (15U) +#define GPIO_BSRR_BS15_Msk (0x1UL << GPIO_BSRR_BS15_Pos) /*!< 0x00008000 */ +#define GPIO_BSRR_BS15 GPIO_BSRR_BS15_Msk +#define GPIO_BSRR_BR0_Pos (16U) +#define GPIO_BSRR_BR0_Msk (0x1UL << GPIO_BSRR_BR0_Pos) /*!< 0x00010000 */ +#define GPIO_BSRR_BR0 GPIO_BSRR_BR0_Msk +#define GPIO_BSRR_BR1_Pos (17U) +#define GPIO_BSRR_BR1_Msk (0x1UL << GPIO_BSRR_BR1_Pos) /*!< 0x00020000 */ +#define GPIO_BSRR_BR1 GPIO_BSRR_BR1_Msk +#define GPIO_BSRR_BR2_Pos (18U) +#define GPIO_BSRR_BR2_Msk (0x1UL << GPIO_BSRR_BR2_Pos) /*!< 0x00040000 */ +#define GPIO_BSRR_BR2 GPIO_BSRR_BR2_Msk +#define GPIO_BSRR_BR3_Pos (19U) +#define GPIO_BSRR_BR3_Msk (0x1UL << GPIO_BSRR_BR3_Pos) /*!< 0x00080000 */ +#define GPIO_BSRR_BR3 GPIO_BSRR_BR3_Msk +#define GPIO_BSRR_BR4_Pos (20U) +#define GPIO_BSRR_BR4_Msk (0x1UL << GPIO_BSRR_BR4_Pos) /*!< 0x00100000 */ +#define GPIO_BSRR_BR4 GPIO_BSRR_BR4_Msk +#define GPIO_BSRR_BR5_Pos (21U) +#define GPIO_BSRR_BR5_Msk (0x1UL << GPIO_BSRR_BR5_Pos) /*!< 0x00200000 */ +#define GPIO_BSRR_BR5 GPIO_BSRR_BR5_Msk +#define GPIO_BSRR_BR6_Pos (22U) +#define GPIO_BSRR_BR6_Msk (0x1UL << GPIO_BSRR_BR6_Pos) /*!< 0x00400000 */ +#define GPIO_BSRR_BR6 GPIO_BSRR_BR6_Msk +#define GPIO_BSRR_BR7_Pos (23U) +#define GPIO_BSRR_BR7_Msk (0x1UL << GPIO_BSRR_BR7_Pos) /*!< 0x00800000 */ +#define GPIO_BSRR_BR7 GPIO_BSRR_BR7_Msk +#define GPIO_BSRR_BR8_Pos (24U) +#define GPIO_BSRR_BR8_Msk (0x1UL << GPIO_BSRR_BR8_Pos) /*!< 0x01000000 */ +#define GPIO_BSRR_BR8 GPIO_BSRR_BR8_Msk +#define GPIO_BSRR_BR9_Pos (25U) +#define GPIO_BSRR_BR9_Msk (0x1UL << GPIO_BSRR_BR9_Pos) /*!< 0x02000000 */ +#define GPIO_BSRR_BR9 GPIO_BSRR_BR9_Msk +#define GPIO_BSRR_BR10_Pos (26U) +#define GPIO_BSRR_BR10_Msk (0x1UL << GPIO_BSRR_BR10_Pos) /*!< 0x04000000 */ +#define GPIO_BSRR_BR10 GPIO_BSRR_BR10_Msk +#define GPIO_BSRR_BR11_Pos (27U) +#define GPIO_BSRR_BR11_Msk (0x1UL << GPIO_BSRR_BR11_Pos) /*!< 0x08000000 */ +#define GPIO_BSRR_BR11 GPIO_BSRR_BR11_Msk +#define GPIO_BSRR_BR12_Pos (28U) +#define GPIO_BSRR_BR12_Msk (0x1UL << GPIO_BSRR_BR12_Pos) /*!< 0x10000000 */ +#define GPIO_BSRR_BR12 GPIO_BSRR_BR12_Msk +#define GPIO_BSRR_BR13_Pos (29U) +#define GPIO_BSRR_BR13_Msk (0x1UL << GPIO_BSRR_BR13_Pos) /*!< 0x20000000 */ +#define GPIO_BSRR_BR13 GPIO_BSRR_BR13_Msk +#define GPIO_BSRR_BR14_Pos (30U) +#define GPIO_BSRR_BR14_Msk (0x1UL << GPIO_BSRR_BR14_Pos) /*!< 0x40000000 */ +#define GPIO_BSRR_BR14 GPIO_BSRR_BR14_Msk +#define GPIO_BSRR_BR15_Pos (31U) +#define GPIO_BSRR_BR15_Msk (0x1UL << GPIO_BSRR_BR15_Pos) /*!< 0x80000000 */ +#define GPIO_BSRR_BR15 GPIO_BSRR_BR15_Msk + +/* Legacy defines */ +#define GPIO_BSRR_BS_0 GPIO_BSRR_BS0 +#define GPIO_BSRR_BS_1 GPIO_BSRR_BS1 +#define GPIO_BSRR_BS_2 GPIO_BSRR_BS2 +#define GPIO_BSRR_BS_3 GPIO_BSRR_BS3 +#define GPIO_BSRR_BS_4 GPIO_BSRR_BS4 +#define GPIO_BSRR_BS_5 GPIO_BSRR_BS5 +#define GPIO_BSRR_BS_6 GPIO_BSRR_BS6 +#define GPIO_BSRR_BS_7 GPIO_BSRR_BS7 +#define GPIO_BSRR_BS_8 GPIO_BSRR_BS8 +#define GPIO_BSRR_BS_9 GPIO_BSRR_BS9 +#define GPIO_BSRR_BS_10 GPIO_BSRR_BS10 +#define GPIO_BSRR_BS_11 GPIO_BSRR_BS11 +#define GPIO_BSRR_BS_12 GPIO_BSRR_BS12 +#define GPIO_BSRR_BS_13 GPIO_BSRR_BS13 +#define GPIO_BSRR_BS_14 GPIO_BSRR_BS14 +#define GPIO_BSRR_BS_15 GPIO_BSRR_BS15 +#define GPIO_BSRR_BR_0 GPIO_BSRR_BR0 +#define GPIO_BSRR_BR_1 GPIO_BSRR_BR1 +#define GPIO_BSRR_BR_2 GPIO_BSRR_BR2 +#define GPIO_BSRR_BR_3 GPIO_BSRR_BR3 +#define GPIO_BSRR_BR_4 GPIO_BSRR_BR4 +#define GPIO_BSRR_BR_5 GPIO_BSRR_BR5 +#define GPIO_BSRR_BR_6 GPIO_BSRR_BR6 +#define GPIO_BSRR_BR_7 GPIO_BSRR_BR7 +#define GPIO_BSRR_BR_8 GPIO_BSRR_BR8 +#define GPIO_BSRR_BR_9 GPIO_BSRR_BR9 +#define GPIO_BSRR_BR_10 GPIO_BSRR_BR10 +#define GPIO_BSRR_BR_11 GPIO_BSRR_BR11 +#define GPIO_BSRR_BR_12 GPIO_BSRR_BR12 +#define GPIO_BSRR_BR_13 GPIO_BSRR_BR13 +#define GPIO_BSRR_BR_14 GPIO_BSRR_BR14 +#define GPIO_BSRR_BR_15 GPIO_BSRR_BR15 + +/****************** Bit definition for GPIO_LCKR register *********************/ +#define GPIO_LCKR_LCK0_Pos (0U) +#define GPIO_LCKR_LCK0_Msk (0x1UL << GPIO_LCKR_LCK0_Pos) /*!< 0x00000001 */ +#define GPIO_LCKR_LCK0 GPIO_LCKR_LCK0_Msk +#define GPIO_LCKR_LCK1_Pos (1U) +#define GPIO_LCKR_LCK1_Msk (0x1UL << GPIO_LCKR_LCK1_Pos) /*!< 0x00000002 */ +#define GPIO_LCKR_LCK1 GPIO_LCKR_LCK1_Msk +#define GPIO_LCKR_LCK2_Pos (2U) +#define GPIO_LCKR_LCK2_Msk (0x1UL << GPIO_LCKR_LCK2_Pos) /*!< 0x00000004 */ +#define GPIO_LCKR_LCK2 GPIO_LCKR_LCK2_Msk +#define GPIO_LCKR_LCK3_Pos (3U) +#define GPIO_LCKR_LCK3_Msk (0x1UL << GPIO_LCKR_LCK3_Pos) /*!< 0x00000008 */ +#define GPIO_LCKR_LCK3 GPIO_LCKR_LCK3_Msk +#define GPIO_LCKR_LCK4_Pos (4U) +#define GPIO_LCKR_LCK4_Msk (0x1UL << GPIO_LCKR_LCK4_Pos) /*!< 0x00000010 */ +#define GPIO_LCKR_LCK4 GPIO_LCKR_LCK4_Msk +#define GPIO_LCKR_LCK5_Pos (5U) +#define GPIO_LCKR_LCK5_Msk (0x1UL << GPIO_LCKR_LCK5_Pos) /*!< 0x00000020 */ +#define GPIO_LCKR_LCK5 GPIO_LCKR_LCK5_Msk +#define GPIO_LCKR_LCK6_Pos (6U) +#define GPIO_LCKR_LCK6_Msk (0x1UL << GPIO_LCKR_LCK6_Pos) /*!< 0x00000040 */ +#define GPIO_LCKR_LCK6 GPIO_LCKR_LCK6_Msk +#define GPIO_LCKR_LCK7_Pos (7U) +#define GPIO_LCKR_LCK7_Msk (0x1UL << GPIO_LCKR_LCK7_Pos) /*!< 0x00000080 */ +#define GPIO_LCKR_LCK7 GPIO_LCKR_LCK7_Msk +#define GPIO_LCKR_LCK8_Pos (8U) +#define GPIO_LCKR_LCK8_Msk (0x1UL << GPIO_LCKR_LCK8_Pos) /*!< 0x00000100 */ +#define GPIO_LCKR_LCK8 GPIO_LCKR_LCK8_Msk +#define GPIO_LCKR_LCK9_Pos (9U) +#define GPIO_LCKR_LCK9_Msk (0x1UL << GPIO_LCKR_LCK9_Pos) /*!< 0x00000200 */ +#define GPIO_LCKR_LCK9 GPIO_LCKR_LCK9_Msk +#define GPIO_LCKR_LCK10_Pos (10U) +#define GPIO_LCKR_LCK10_Msk (0x1UL << GPIO_LCKR_LCK10_Pos) /*!< 0x00000400 */ +#define GPIO_LCKR_LCK10 GPIO_LCKR_LCK10_Msk +#define GPIO_LCKR_LCK11_Pos (11U) +#define GPIO_LCKR_LCK11_Msk (0x1UL << GPIO_LCKR_LCK11_Pos) /*!< 0x00000800 */ +#define GPIO_LCKR_LCK11 GPIO_LCKR_LCK11_Msk +#define GPIO_LCKR_LCK12_Pos (12U) +#define GPIO_LCKR_LCK12_Msk (0x1UL << GPIO_LCKR_LCK12_Pos) /*!< 0x00001000 */ +#define GPIO_LCKR_LCK12 GPIO_LCKR_LCK12_Msk +#define GPIO_LCKR_LCK13_Pos (13U) +#define GPIO_LCKR_LCK13_Msk (0x1UL << GPIO_LCKR_LCK13_Pos) /*!< 0x00002000 */ +#define GPIO_LCKR_LCK13 GPIO_LCKR_LCK13_Msk +#define GPIO_LCKR_LCK14_Pos (14U) +#define GPIO_LCKR_LCK14_Msk (0x1UL << GPIO_LCKR_LCK14_Pos) /*!< 0x00004000 */ +#define GPIO_LCKR_LCK14 GPIO_LCKR_LCK14_Msk +#define GPIO_LCKR_LCK15_Pos (15U) +#define GPIO_LCKR_LCK15_Msk (0x1UL << GPIO_LCKR_LCK15_Pos) /*!< 0x00008000 */ +#define GPIO_LCKR_LCK15 GPIO_LCKR_LCK15_Msk +#define GPIO_LCKR_LCKK_Pos (16U) +#define GPIO_LCKR_LCKK_Msk (0x1UL << GPIO_LCKR_LCKK_Pos) /*!< 0x00010000 */ +#define GPIO_LCKR_LCKK GPIO_LCKR_LCKK_Msk + +/****************** Bit definition for GPIO_AFRL register *********************/ +#define GPIO_AFRL_AFSEL0_Pos (0U) +#define GPIO_AFRL_AFSEL0_Msk (0xFUL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x0000000F */ +#define GPIO_AFRL_AFSEL0 GPIO_AFRL_AFSEL0_Msk +#define GPIO_AFRL_AFSEL0_0 (0x1UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000001 */ +#define GPIO_AFRL_AFSEL0_1 (0x2UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000002 */ +#define GPIO_AFRL_AFSEL0_2 (0x4UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000004 */ +#define GPIO_AFRL_AFSEL0_3 (0x8UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000008 */ +#define GPIO_AFRL_AFSEL1_Pos (4U) +#define GPIO_AFRL_AFSEL1_Msk (0xFUL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x000000F0 */ +#define GPIO_AFRL_AFSEL1 GPIO_AFRL_AFSEL1_Msk +#define GPIO_AFRL_AFSEL1_0 (0x1UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000010 */ +#define GPIO_AFRL_AFSEL1_1 (0x2UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000020 */ +#define GPIO_AFRL_AFSEL1_2 (0x4UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000040 */ +#define GPIO_AFRL_AFSEL1_3 (0x8UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000080 */ +#define GPIO_AFRL_AFSEL2_Pos (8U) +#define GPIO_AFRL_AFSEL2_Msk (0xFUL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000F00 */ +#define GPIO_AFRL_AFSEL2 GPIO_AFRL_AFSEL2_Msk +#define GPIO_AFRL_AFSEL2_0 (0x1UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000100 */ +#define GPIO_AFRL_AFSEL2_1 (0x2UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000200 */ +#define GPIO_AFRL_AFSEL2_2 (0x4UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000400 */ +#define GPIO_AFRL_AFSEL2_3 (0x8UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000800 */ +#define GPIO_AFRL_AFSEL3_Pos (12U) +#define GPIO_AFRL_AFSEL3_Msk (0xFUL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x0000F000 */ +#define GPIO_AFRL_AFSEL3 GPIO_AFRL_AFSEL3_Msk +#define GPIO_AFRL_AFSEL3_0 (0x1UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00001000 */ +#define GPIO_AFRL_AFSEL3_1 (0x2UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00002000 */ +#define GPIO_AFRL_AFSEL3_2 (0x4UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00004000 */ +#define GPIO_AFRL_AFSEL3_3 (0x8UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00008000 */ +#define GPIO_AFRL_AFSEL4_Pos (16U) +#define GPIO_AFRL_AFSEL4_Msk (0xFUL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x000F0000 */ +#define GPIO_AFRL_AFSEL4 GPIO_AFRL_AFSEL4_Msk +#define GPIO_AFRL_AFSEL4_0 (0x1UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00010000 */ +#define GPIO_AFRL_AFSEL4_1 (0x2UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00020000 */ +#define GPIO_AFRL_AFSEL4_2 (0x4UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00040000 */ +#define GPIO_AFRL_AFSEL4_3 (0x8UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00080000 */ +#define GPIO_AFRL_AFSEL5_Pos (20U) +#define GPIO_AFRL_AFSEL5_Msk (0xFUL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00F00000 */ +#define GPIO_AFRL_AFSEL5 GPIO_AFRL_AFSEL5_Msk +#define GPIO_AFRL_AFSEL5_0 (0x1UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00100000 */ +#define GPIO_AFRL_AFSEL5_1 (0x2UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00200000 */ +#define GPIO_AFRL_AFSEL5_2 (0x4UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00400000 */ +#define GPIO_AFRL_AFSEL5_3 (0x8UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00800000 */ +#define GPIO_AFRL_AFSEL6_Pos (24U) +#define GPIO_AFRL_AFSEL6_Msk (0xFUL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x0F000000 */ +#define GPIO_AFRL_AFSEL6 GPIO_AFRL_AFSEL6_Msk +#define GPIO_AFRL_AFSEL6_0 (0x1UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x01000000 */ +#define GPIO_AFRL_AFSEL6_1 (0x2UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x02000000 */ +#define GPIO_AFRL_AFSEL6_2 (0x4UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x04000000 */ +#define GPIO_AFRL_AFSEL6_3 (0x8UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x08000000 */ +#define GPIO_AFRL_AFSEL7_Pos (28U) +#define GPIO_AFRL_AFSEL7_Msk (0xFUL << GPIO_AFRL_AFSEL7_Pos) /*!< 0xF0000000 */ +#define GPIO_AFRL_AFSEL7 GPIO_AFRL_AFSEL7_Msk +#define GPIO_AFRL_AFSEL7_0 (0x1UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x10000000 */ +#define GPIO_AFRL_AFSEL7_1 (0x2UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x20000000 */ +#define GPIO_AFRL_AFSEL7_2 (0x4UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x40000000 */ +#define GPIO_AFRL_AFSEL7_3 (0x8UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_AFRL_AFRL0 GPIO_AFRL_AFSEL0 +#define GPIO_AFRL_AFRL1 GPIO_AFRL_AFSEL1 +#define GPIO_AFRL_AFRL2 GPIO_AFRL_AFSEL2 +#define GPIO_AFRL_AFRL3 GPIO_AFRL_AFSEL3 +#define GPIO_AFRL_AFRL4 GPIO_AFRL_AFSEL4 +#define GPIO_AFRL_AFRL5 GPIO_AFRL_AFSEL5 +#define GPIO_AFRL_AFRL6 GPIO_AFRL_AFSEL6 +#define GPIO_AFRL_AFRL7 GPIO_AFRL_AFSEL7 + +/****************** Bit definition for GPIO_AFRH register *********************/ +#define GPIO_AFRH_AFSEL8_Pos (0U) +#define GPIO_AFRH_AFSEL8_Msk (0xFUL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x0000000F */ +#define GPIO_AFRH_AFSEL8 GPIO_AFRH_AFSEL8_Msk +#define GPIO_AFRH_AFSEL8_0 (0x1UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000001 */ +#define GPIO_AFRH_AFSEL8_1 (0x2UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000002 */ +#define GPIO_AFRH_AFSEL8_2 (0x4UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000004 */ +#define GPIO_AFRH_AFSEL8_3 (0x8UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000008 */ +#define GPIO_AFRH_AFSEL9_Pos (4U) +#define GPIO_AFRH_AFSEL9_Msk (0xFUL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x000000F0 */ +#define GPIO_AFRH_AFSEL9 GPIO_AFRH_AFSEL9_Msk +#define GPIO_AFRH_AFSEL9_0 (0x1UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000010 */ +#define GPIO_AFRH_AFSEL9_1 (0x2UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000020 */ +#define GPIO_AFRH_AFSEL9_2 (0x4UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000040 */ +#define GPIO_AFRH_AFSEL9_3 (0x8UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000080 */ +#define GPIO_AFRH_AFSEL10_Pos (8U) +#define GPIO_AFRH_AFSEL10_Msk (0xFUL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000F00 */ +#define GPIO_AFRH_AFSEL10 GPIO_AFRH_AFSEL10_Msk +#define GPIO_AFRH_AFSEL10_0 (0x1UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000100 */ +#define GPIO_AFRH_AFSEL10_1 (0x2UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000200 */ +#define GPIO_AFRH_AFSEL10_2 (0x4UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000400 */ +#define GPIO_AFRH_AFSEL10_3 (0x8UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000800 */ +#define GPIO_AFRH_AFSEL11_Pos (12U) +#define GPIO_AFRH_AFSEL11_Msk (0xFUL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x0000F000 */ +#define GPIO_AFRH_AFSEL11 GPIO_AFRH_AFSEL11_Msk +#define GPIO_AFRH_AFSEL11_0 (0x1UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00001000 */ +#define GPIO_AFRH_AFSEL11_1 (0x2UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00002000 */ +#define GPIO_AFRH_AFSEL11_2 (0x4UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00004000 */ +#define GPIO_AFRH_AFSEL11_3 (0x8UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00008000 */ +#define GPIO_AFRH_AFSEL12_Pos (16U) +#define GPIO_AFRH_AFSEL12_Msk (0xFUL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x000F0000 */ +#define GPIO_AFRH_AFSEL12 GPIO_AFRH_AFSEL12_Msk +#define GPIO_AFRH_AFSEL12_0 (0x1UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00010000 */ +#define GPIO_AFRH_AFSEL12_1 (0x2UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00020000 */ +#define GPIO_AFRH_AFSEL12_2 (0x4UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00040000 */ +#define GPIO_AFRH_AFSEL12_3 (0x8UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00080000 */ +#define GPIO_AFRH_AFSEL13_Pos (20U) +#define GPIO_AFRH_AFSEL13_Msk (0xFUL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00F00000 */ +#define GPIO_AFRH_AFSEL13 GPIO_AFRH_AFSEL13_Msk +#define GPIO_AFRH_AFSEL13_0 (0x1UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00100000 */ +#define GPIO_AFRH_AFSEL13_1 (0x2UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00200000 */ +#define GPIO_AFRH_AFSEL13_2 (0x4UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00400000 */ +#define GPIO_AFRH_AFSEL13_3 (0x8UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00800000 */ +#define GPIO_AFRH_AFSEL14_Pos (24U) +#define GPIO_AFRH_AFSEL14_Msk (0xFUL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x0F000000 */ +#define GPIO_AFRH_AFSEL14 GPIO_AFRH_AFSEL14_Msk +#define GPIO_AFRH_AFSEL14_0 (0x1UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x01000000 */ +#define GPIO_AFRH_AFSEL14_1 (0x2UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x02000000 */ +#define GPIO_AFRH_AFSEL14_2 (0x4UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x04000000 */ +#define GPIO_AFRH_AFSEL14_3 (0x8UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x08000000 */ +#define GPIO_AFRH_AFSEL15_Pos (28U) +#define GPIO_AFRH_AFSEL15_Msk (0xFUL << GPIO_AFRH_AFSEL15_Pos) /*!< 0xF0000000 */ +#define GPIO_AFRH_AFSEL15 GPIO_AFRH_AFSEL15_Msk +#define GPIO_AFRH_AFSEL15_0 (0x1UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x10000000 */ +#define GPIO_AFRH_AFSEL15_1 (0x2UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x20000000 */ +#define GPIO_AFRH_AFSEL15_2 (0x4UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x40000000 */ +#define GPIO_AFRH_AFSEL15_3 (0x8UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_AFRH_AFRH0 GPIO_AFRH_AFSEL8 +#define GPIO_AFRH_AFRH1 GPIO_AFRH_AFSEL9 +#define GPIO_AFRH_AFRH2 GPIO_AFRH_AFSEL10 +#define GPIO_AFRH_AFRH3 GPIO_AFRH_AFSEL11 +#define GPIO_AFRH_AFRH4 GPIO_AFRH_AFSEL12 +#define GPIO_AFRH_AFRH5 GPIO_AFRH_AFSEL13 +#define GPIO_AFRH_AFRH6 GPIO_AFRH_AFSEL14 +#define GPIO_AFRH_AFRH7 GPIO_AFRH_AFSEL15 + +/****************** Bits definition for GPIO_BRR register ******************/ +#define GPIO_BRR_BR0_Pos (0U) +#define GPIO_BRR_BR0_Msk (0x1UL << GPIO_BRR_BR0_Pos) /*!< 0x00000001 */ +#define GPIO_BRR_BR0 GPIO_BRR_BR0_Msk +#define GPIO_BRR_BR1_Pos (1U) +#define GPIO_BRR_BR1_Msk (0x1UL << GPIO_BRR_BR1_Pos) /*!< 0x00000002 */ +#define GPIO_BRR_BR1 GPIO_BRR_BR1_Msk +#define GPIO_BRR_BR2_Pos (2U) +#define GPIO_BRR_BR2_Msk (0x1UL << GPIO_BRR_BR2_Pos) /*!< 0x00000004 */ +#define GPIO_BRR_BR2 GPIO_BRR_BR2_Msk +#define GPIO_BRR_BR3_Pos (3U) +#define GPIO_BRR_BR3_Msk (0x1UL << GPIO_BRR_BR3_Pos) /*!< 0x00000008 */ +#define GPIO_BRR_BR3 GPIO_BRR_BR3_Msk +#define GPIO_BRR_BR4_Pos (4U) +#define GPIO_BRR_BR4_Msk (0x1UL << GPIO_BRR_BR4_Pos) /*!< 0x00000010 */ +#define GPIO_BRR_BR4 GPIO_BRR_BR4_Msk +#define GPIO_BRR_BR5_Pos (5U) +#define GPIO_BRR_BR5_Msk (0x1UL << GPIO_BRR_BR5_Pos) /*!< 0x00000020 */ +#define GPIO_BRR_BR5 GPIO_BRR_BR5_Msk +#define GPIO_BRR_BR6_Pos (6U) +#define GPIO_BRR_BR6_Msk (0x1UL << GPIO_BRR_BR6_Pos) /*!< 0x00000040 */ +#define GPIO_BRR_BR6 GPIO_BRR_BR6_Msk +#define GPIO_BRR_BR7_Pos (7U) +#define GPIO_BRR_BR7_Msk (0x1UL << GPIO_BRR_BR7_Pos) /*!< 0x00000080 */ +#define GPIO_BRR_BR7 GPIO_BRR_BR7_Msk +#define GPIO_BRR_BR8_Pos (8U) +#define GPIO_BRR_BR8_Msk (0x1UL << GPIO_BRR_BR8_Pos) /*!< 0x00000100 */ +#define GPIO_BRR_BR8 GPIO_BRR_BR8_Msk +#define GPIO_BRR_BR9_Pos (9U) +#define GPIO_BRR_BR9_Msk (0x1UL << GPIO_BRR_BR9_Pos) /*!< 0x00000200 */ +#define GPIO_BRR_BR9 GPIO_BRR_BR9_Msk +#define GPIO_BRR_BR10_Pos (10U) +#define GPIO_BRR_BR10_Msk (0x1UL << GPIO_BRR_BR10_Pos) /*!< 0x00000400 */ +#define GPIO_BRR_BR10 GPIO_BRR_BR10_Msk +#define GPIO_BRR_BR11_Pos (11U) +#define GPIO_BRR_BR11_Msk (0x1UL << GPIO_BRR_BR11_Pos) /*!< 0x00000800 */ +#define GPIO_BRR_BR11 GPIO_BRR_BR11_Msk +#define GPIO_BRR_BR12_Pos (12U) +#define GPIO_BRR_BR12_Msk (0x1UL << GPIO_BRR_BR12_Pos) /*!< 0x00001000 */ +#define GPIO_BRR_BR12 GPIO_BRR_BR12_Msk +#define GPIO_BRR_BR13_Pos (13U) +#define GPIO_BRR_BR13_Msk (0x1UL << GPIO_BRR_BR13_Pos) /*!< 0x00002000 */ +#define GPIO_BRR_BR13 GPIO_BRR_BR13_Msk +#define GPIO_BRR_BR14_Pos (14U) +#define GPIO_BRR_BR14_Msk (0x1UL << GPIO_BRR_BR14_Pos) /*!< 0x00004000 */ +#define GPIO_BRR_BR14 GPIO_BRR_BR14_Msk +#define GPIO_BRR_BR15_Pos (15U) +#define GPIO_BRR_BR15_Msk (0x1UL << GPIO_BRR_BR15_Pos) /*!< 0x00008000 */ +#define GPIO_BRR_BR15 GPIO_BRR_BR15_Msk + +/* Legacy defines */ +#define GPIO_BRR_BR_0 GPIO_BRR_BR0 +#define GPIO_BRR_BR_1 GPIO_BRR_BR1 +#define GPIO_BRR_BR_2 GPIO_BRR_BR2 +#define GPIO_BRR_BR_3 GPIO_BRR_BR3 +#define GPIO_BRR_BR_4 GPIO_BRR_BR4 +#define GPIO_BRR_BR_5 GPIO_BRR_BR5 +#define GPIO_BRR_BR_6 GPIO_BRR_BR6 +#define GPIO_BRR_BR_7 GPIO_BRR_BR7 +#define GPIO_BRR_BR_8 GPIO_BRR_BR8 +#define GPIO_BRR_BR_9 GPIO_BRR_BR9 +#define GPIO_BRR_BR_10 GPIO_BRR_BR10 +#define GPIO_BRR_BR_11 GPIO_BRR_BR11 +#define GPIO_BRR_BR_12 GPIO_BRR_BR12 +#define GPIO_BRR_BR_13 GPIO_BRR_BR13 +#define GPIO_BRR_BR_14 GPIO_BRR_BR14 +#define GPIO_BRR_BR_15 GPIO_BRR_BR15 + + + +/******************************************************************************/ +/* */ +/* Inter-integrated Circuit Interface (I2C) */ +/* */ +/******************************************************************************/ +/******************* Bit definition for I2C_CR1 register *******************/ +#define I2C_CR1_PE_Pos (0U) +#define I2C_CR1_PE_Msk (0x1UL << I2C_CR1_PE_Pos) /*!< 0x00000001 */ +#define I2C_CR1_PE I2C_CR1_PE_Msk /*!< Peripheral enable */ +#define I2C_CR1_TXIE_Pos (1U) +#define I2C_CR1_TXIE_Msk (0x1UL << I2C_CR1_TXIE_Pos) /*!< 0x00000002 */ +#define I2C_CR1_TXIE I2C_CR1_TXIE_Msk /*!< TX interrupt enable */ +#define I2C_CR1_RXIE_Pos (2U) +#define I2C_CR1_RXIE_Msk (0x1UL << I2C_CR1_RXIE_Pos) /*!< 0x00000004 */ +#define I2C_CR1_RXIE I2C_CR1_RXIE_Msk /*!< RX interrupt enable */ +#define I2C_CR1_ADDRIE_Pos (3U) +#define I2C_CR1_ADDRIE_Msk (0x1UL << I2C_CR1_ADDRIE_Pos) /*!< 0x00000008 */ +#define I2C_CR1_ADDRIE I2C_CR1_ADDRIE_Msk /*!< Address match interrupt enable */ +#define I2C_CR1_NACKIE_Pos (4U) +#define I2C_CR1_NACKIE_Msk (0x1UL << I2C_CR1_NACKIE_Pos) /*!< 0x00000010 */ +#define I2C_CR1_NACKIE I2C_CR1_NACKIE_Msk /*!< NACK received interrupt enable */ +#define I2C_CR1_STOPIE_Pos (5U) +#define I2C_CR1_STOPIE_Msk (0x1UL << I2C_CR1_STOPIE_Pos) /*!< 0x00000020 */ +#define I2C_CR1_STOPIE I2C_CR1_STOPIE_Msk /*!< STOP detection interrupt enable */ +#define I2C_CR1_TCIE_Pos (6U) +#define I2C_CR1_TCIE_Msk (0x1UL << I2C_CR1_TCIE_Pos) /*!< 0x00000040 */ +#define I2C_CR1_TCIE I2C_CR1_TCIE_Msk /*!< Transfer complete interrupt enable */ +#define I2C_CR1_ERRIE_Pos (7U) +#define I2C_CR1_ERRIE_Msk (0x1UL << I2C_CR1_ERRIE_Pos) /*!< 0x00000080 */ +#define I2C_CR1_ERRIE I2C_CR1_ERRIE_Msk /*!< Errors interrupt enable */ +#define I2C_CR1_DNF_Pos (8U) +#define I2C_CR1_DNF_Msk (0xFUL << I2C_CR1_DNF_Pos) /*!< 0x00000F00 */ +#define I2C_CR1_DNF I2C_CR1_DNF_Msk /*!< Digital noise filter */ +#define I2C_CR1_ANFOFF_Pos (12U) +#define I2C_CR1_ANFOFF_Msk (0x1UL << I2C_CR1_ANFOFF_Pos) /*!< 0x00001000 */ +#define I2C_CR1_ANFOFF I2C_CR1_ANFOFF_Msk /*!< Analog noise filter OFF */ +#define I2C_CR1_SWRST_Pos (13U) +#define I2C_CR1_SWRST_Msk (0x1UL << I2C_CR1_SWRST_Pos) /*!< 0x00002000 */ +#define I2C_CR1_SWRST I2C_CR1_SWRST_Msk /*!< Software reset */ +#define I2C_CR1_TXDMAEN_Pos (14U) +#define I2C_CR1_TXDMAEN_Msk (0x1UL << I2C_CR1_TXDMAEN_Pos) /*!< 0x00004000 */ +#define I2C_CR1_TXDMAEN I2C_CR1_TXDMAEN_Msk /*!< DMA transmission requests enable */ +#define I2C_CR1_RXDMAEN_Pos (15U) +#define I2C_CR1_RXDMAEN_Msk (0x1UL << I2C_CR1_RXDMAEN_Pos) /*!< 0x00008000 */ +#define I2C_CR1_RXDMAEN I2C_CR1_RXDMAEN_Msk /*!< DMA reception requests enable */ +#define I2C_CR1_SBC_Pos (16U) +#define I2C_CR1_SBC_Msk (0x1UL << I2C_CR1_SBC_Pos) /*!< 0x00010000 */ +#define I2C_CR1_SBC I2C_CR1_SBC_Msk /*!< Slave byte control */ +#define I2C_CR1_NOSTRETCH_Pos (17U) +#define I2C_CR1_NOSTRETCH_Msk (0x1UL << I2C_CR1_NOSTRETCH_Pos) /*!< 0x00020000 */ +#define I2C_CR1_NOSTRETCH I2C_CR1_NOSTRETCH_Msk /*!< Clock stretching disable */ +#define I2C_CR1_WUPEN_Pos (18U) +#define I2C_CR1_WUPEN_Msk (0x1UL << I2C_CR1_WUPEN_Pos) /*!< 0x00040000 */ +#define I2C_CR1_WUPEN I2C_CR1_WUPEN_Msk /*!< Wakeup from STOP enable */ +#define I2C_CR1_GCEN_Pos (19U) +#define I2C_CR1_GCEN_Msk (0x1UL << I2C_CR1_GCEN_Pos) /*!< 0x00080000 */ +#define I2C_CR1_GCEN I2C_CR1_GCEN_Msk /*!< General call enable */ +#define I2C_CR1_SMBHEN_Pos (20U) +#define I2C_CR1_SMBHEN_Msk (0x1UL << I2C_CR1_SMBHEN_Pos) /*!< 0x00100000 */ +#define I2C_CR1_SMBHEN I2C_CR1_SMBHEN_Msk /*!< SMBus host address enable */ +#define I2C_CR1_SMBDEN_Pos (21U) +#define I2C_CR1_SMBDEN_Msk (0x1UL << I2C_CR1_SMBDEN_Pos) /*!< 0x00200000 */ +#define I2C_CR1_SMBDEN I2C_CR1_SMBDEN_Msk /*!< SMBus device default address enable */ +#define I2C_CR1_ALERTEN_Pos (22U) +#define I2C_CR1_ALERTEN_Msk (0x1UL << I2C_CR1_ALERTEN_Pos) /*!< 0x00400000 */ +#define I2C_CR1_ALERTEN I2C_CR1_ALERTEN_Msk /*!< SMBus alert enable */ +#define I2C_CR1_PECEN_Pos (23U) +#define I2C_CR1_PECEN_Msk (0x1UL << I2C_CR1_PECEN_Pos) /*!< 0x00800000 */ +#define I2C_CR1_PECEN I2C_CR1_PECEN_Msk /*!< PEC enable */ + +/****************** Bit definition for I2C_CR2 register ********************/ +#define I2C_CR2_SADD_Pos (0U) +#define I2C_CR2_SADD_Msk (0x3FFUL << I2C_CR2_SADD_Pos) /*!< 0x000003FF */ +#define I2C_CR2_SADD I2C_CR2_SADD_Msk /*!< Slave address (master mode) */ +#define I2C_CR2_RD_WRN_Pos (10U) +#define I2C_CR2_RD_WRN_Msk (0x1UL << I2C_CR2_RD_WRN_Pos) /*!< 0x00000400 */ +#define I2C_CR2_RD_WRN I2C_CR2_RD_WRN_Msk /*!< Transfer direction (master mode) */ +#define I2C_CR2_ADD10_Pos (11U) +#define I2C_CR2_ADD10_Msk (0x1UL << I2C_CR2_ADD10_Pos) /*!< 0x00000800 */ +#define I2C_CR2_ADD10 I2C_CR2_ADD10_Msk /*!< 10-bit addressing mode (master mode) */ +#define I2C_CR2_HEAD10R_Pos (12U) +#define I2C_CR2_HEAD10R_Msk (0x1UL << I2C_CR2_HEAD10R_Pos) /*!< 0x00001000 */ +#define I2C_CR2_HEAD10R I2C_CR2_HEAD10R_Msk /*!< 10-bit address header only read direction (master mode) */ +#define I2C_CR2_START_Pos (13U) +#define I2C_CR2_START_Msk (0x1UL << I2C_CR2_START_Pos) /*!< 0x00002000 */ +#define I2C_CR2_START I2C_CR2_START_Msk /*!< START generation */ +#define I2C_CR2_STOP_Pos (14U) +#define I2C_CR2_STOP_Msk (0x1UL << I2C_CR2_STOP_Pos) /*!< 0x00004000 */ +#define I2C_CR2_STOP I2C_CR2_STOP_Msk /*!< STOP generation (master mode) */ +#define I2C_CR2_NACK_Pos (15U) +#define I2C_CR2_NACK_Msk (0x1UL << I2C_CR2_NACK_Pos) /*!< 0x00008000 */ +#define I2C_CR2_NACK I2C_CR2_NACK_Msk /*!< NACK generation (slave mode) */ +#define I2C_CR2_NBYTES_Pos (16U) +#define I2C_CR2_NBYTES_Msk (0xFFUL << I2C_CR2_NBYTES_Pos) /*!< 0x00FF0000 */ +#define I2C_CR2_NBYTES I2C_CR2_NBYTES_Msk /*!< Number of bytes */ +#define I2C_CR2_RELOAD_Pos (24U) +#define I2C_CR2_RELOAD_Msk (0x1UL << I2C_CR2_RELOAD_Pos) /*!< 0x01000000 */ +#define I2C_CR2_RELOAD I2C_CR2_RELOAD_Msk /*!< NBYTES reload mode */ +#define I2C_CR2_AUTOEND_Pos (25U) +#define I2C_CR2_AUTOEND_Msk (0x1UL << I2C_CR2_AUTOEND_Pos) /*!< 0x02000000 */ +#define I2C_CR2_AUTOEND I2C_CR2_AUTOEND_Msk /*!< Automatic end mode (master mode) */ +#define I2C_CR2_PECBYTE_Pos (26U) +#define I2C_CR2_PECBYTE_Msk (0x1UL << I2C_CR2_PECBYTE_Pos) /*!< 0x04000000 */ +#define I2C_CR2_PECBYTE I2C_CR2_PECBYTE_Msk /*!< Packet error checking byte */ + +/******************* Bit definition for I2C_OAR1 register ******************/ +#define I2C_OAR1_OA1_Pos (0U) +#define I2C_OAR1_OA1_Msk (0x3FFUL << I2C_OAR1_OA1_Pos) /*!< 0x000003FF */ +#define I2C_OAR1_OA1 I2C_OAR1_OA1_Msk /*!< Interface own address 1 */ +#define I2C_OAR1_OA1MODE_Pos (10U) +#define I2C_OAR1_OA1MODE_Msk (0x1UL << I2C_OAR1_OA1MODE_Pos) /*!< 0x00000400 */ +#define I2C_OAR1_OA1MODE I2C_OAR1_OA1MODE_Msk /*!< Own address 1 10-bit mode */ +#define I2C_OAR1_OA1EN_Pos (15U) +#define I2C_OAR1_OA1EN_Msk (0x1UL << I2C_OAR1_OA1EN_Pos) /*!< 0x00008000 */ +#define I2C_OAR1_OA1EN I2C_OAR1_OA1EN_Msk /*!< Own address 1 enable */ + +/******************* Bit definition for I2C_OAR2 register ******************/ +#define I2C_OAR2_OA2_Pos (1U) +#define I2C_OAR2_OA2_Msk (0x7FUL << I2C_OAR2_OA2_Pos) /*!< 0x000000FE */ +#define I2C_OAR2_OA2 I2C_OAR2_OA2_Msk /*!< Interface own address 2 */ +#define I2C_OAR2_OA2MSK_Pos (8U) +#define I2C_OAR2_OA2MSK_Msk (0x7UL << I2C_OAR2_OA2MSK_Pos) /*!< 0x00000700 */ +#define I2C_OAR2_OA2MSK I2C_OAR2_OA2MSK_Msk /*!< Own address 2 masks */ +#define I2C_OAR2_OA2NOMASK (0x00000000UL) /*!< No mask */ +#define I2C_OAR2_OA2MASK01_Pos (8U) +#define I2C_OAR2_OA2MASK01_Msk (0x1UL << I2C_OAR2_OA2MASK01_Pos) /*!< 0x00000100 */ +#define I2C_OAR2_OA2MASK01 I2C_OAR2_OA2MASK01_Msk /*!< OA2[1] is masked, Only OA2[7:2] are compared */ +#define I2C_OAR2_OA2MASK02_Pos (9U) +#define I2C_OAR2_OA2MASK02_Msk (0x1UL << I2C_OAR2_OA2MASK02_Pos) /*!< 0x00000200 */ +#define I2C_OAR2_OA2MASK02 I2C_OAR2_OA2MASK02_Msk /*!< OA2[2:1] is masked, Only OA2[7:3] are compared */ +#define I2C_OAR2_OA2MASK03_Pos (8U) +#define I2C_OAR2_OA2MASK03_Msk (0x3UL << I2C_OAR2_OA2MASK03_Pos) /*!< 0x00000300 */ +#define I2C_OAR2_OA2MASK03 I2C_OAR2_OA2MASK03_Msk /*!< OA2[3:1] is masked, Only OA2[7:4] are compared */ +#define I2C_OAR2_OA2MASK04_Pos (10U) +#define I2C_OAR2_OA2MASK04_Msk (0x1UL << I2C_OAR2_OA2MASK04_Pos) /*!< 0x00000400 */ +#define I2C_OAR2_OA2MASK04 I2C_OAR2_OA2MASK04_Msk /*!< OA2[4:1] is masked, Only OA2[7:5] are compared */ +#define I2C_OAR2_OA2MASK05_Pos (8U) +#define I2C_OAR2_OA2MASK05_Msk (0x5UL << I2C_OAR2_OA2MASK05_Pos) /*!< 0x00000500 */ +#define I2C_OAR2_OA2MASK05 I2C_OAR2_OA2MASK05_Msk /*!< OA2[5:1] is masked, Only OA2[7:6] are compared */ +#define I2C_OAR2_OA2MASK06_Pos (9U) +#define I2C_OAR2_OA2MASK06_Msk (0x3UL << I2C_OAR2_OA2MASK06_Pos) /*!< 0x00000600 */ +#define I2C_OAR2_OA2MASK06 I2C_OAR2_OA2MASK06_Msk /*!< OA2[6:1] is masked, Only OA2[7] are compared */ +#define I2C_OAR2_OA2MASK07_Pos (8U) +#define I2C_OAR2_OA2MASK07_Msk (0x7UL << I2C_OAR2_OA2MASK07_Pos) /*!< 0x00000700 */ +#define I2C_OAR2_OA2MASK07 I2C_OAR2_OA2MASK07_Msk /*!< OA2[7:1] is masked, No comparison is done */ +#define I2C_OAR2_OA2EN_Pos (15U) +#define I2C_OAR2_OA2EN_Msk (0x1UL << I2C_OAR2_OA2EN_Pos) /*!< 0x00008000 */ +#define I2C_OAR2_OA2EN I2C_OAR2_OA2EN_Msk /*!< Own address 2 enable */ + +/******************* Bit definition for I2C_TIMINGR register *******************/ +#define I2C_TIMINGR_SCLL_Pos (0U) +#define I2C_TIMINGR_SCLL_Msk (0xFFUL << I2C_TIMINGR_SCLL_Pos) /*!< 0x000000FF */ +#define I2C_TIMINGR_SCLL I2C_TIMINGR_SCLL_Msk /*!< SCL low period (master mode) */ +#define I2C_TIMINGR_SCLH_Pos (8U) +#define I2C_TIMINGR_SCLH_Msk (0xFFUL << I2C_TIMINGR_SCLH_Pos) /*!< 0x0000FF00 */ +#define I2C_TIMINGR_SCLH I2C_TIMINGR_SCLH_Msk /*!< SCL high period (master mode) */ +#define I2C_TIMINGR_SDADEL_Pos (16U) +#define I2C_TIMINGR_SDADEL_Msk (0xFUL << I2C_TIMINGR_SDADEL_Pos) /*!< 0x000F0000 */ +#define I2C_TIMINGR_SDADEL I2C_TIMINGR_SDADEL_Msk /*!< Data hold time */ +#define I2C_TIMINGR_SCLDEL_Pos (20U) +#define I2C_TIMINGR_SCLDEL_Msk (0xFUL << I2C_TIMINGR_SCLDEL_Pos) /*!< 0x00F00000 */ +#define I2C_TIMINGR_SCLDEL I2C_TIMINGR_SCLDEL_Msk /*!< Data setup time */ +#define I2C_TIMINGR_PRESC_Pos (28U) +#define I2C_TIMINGR_PRESC_Msk (0xFUL << I2C_TIMINGR_PRESC_Pos) /*!< 0xF0000000 */ +#define I2C_TIMINGR_PRESC I2C_TIMINGR_PRESC_Msk /*!< Timings prescaler */ + +/******************* Bit definition for I2C_TIMEOUTR register *******************/ +#define I2C_TIMEOUTR_TIMEOUTA_Pos (0U) +#define I2C_TIMEOUTR_TIMEOUTA_Msk (0xFFFUL << I2C_TIMEOUTR_TIMEOUTA_Pos) /*!< 0x00000FFF */ +#define I2C_TIMEOUTR_TIMEOUTA I2C_TIMEOUTR_TIMEOUTA_Msk /*!< Bus timeout A */ +#define I2C_TIMEOUTR_TIDLE_Pos (12U) +#define I2C_TIMEOUTR_TIDLE_Msk (0x1UL << I2C_TIMEOUTR_TIDLE_Pos) /*!< 0x00001000 */ +#define I2C_TIMEOUTR_TIDLE I2C_TIMEOUTR_TIDLE_Msk /*!< Idle clock timeout detection */ +#define I2C_TIMEOUTR_TIMOUTEN_Pos (15U) +#define I2C_TIMEOUTR_TIMOUTEN_Msk (0x1UL << I2C_TIMEOUTR_TIMOUTEN_Pos) /*!< 0x00008000 */ +#define I2C_TIMEOUTR_TIMOUTEN I2C_TIMEOUTR_TIMOUTEN_Msk /*!< Clock timeout enable */ +#define I2C_TIMEOUTR_TIMEOUTB_Pos (16U) +#define I2C_TIMEOUTR_TIMEOUTB_Msk (0xFFFUL << I2C_TIMEOUTR_TIMEOUTB_Pos) /*!< 0x0FFF0000 */ +#define I2C_TIMEOUTR_TIMEOUTB I2C_TIMEOUTR_TIMEOUTB_Msk /*!< Bus timeout B */ +#define I2C_TIMEOUTR_TEXTEN_Pos (31U) +#define I2C_TIMEOUTR_TEXTEN_Msk (0x1UL << I2C_TIMEOUTR_TEXTEN_Pos) /*!< 0x80000000 */ +#define I2C_TIMEOUTR_TEXTEN I2C_TIMEOUTR_TEXTEN_Msk /*!< Extended clock timeout enable */ + +/****************** Bit definition for I2C_ISR register *********************/ +#define I2C_ISR_TXE_Pos (0U) +#define I2C_ISR_TXE_Msk (0x1UL << I2C_ISR_TXE_Pos) /*!< 0x00000001 */ +#define I2C_ISR_TXE I2C_ISR_TXE_Msk /*!< Transmit data register empty */ +#define I2C_ISR_TXIS_Pos (1U) +#define I2C_ISR_TXIS_Msk (0x1UL << I2C_ISR_TXIS_Pos) /*!< 0x00000002 */ +#define I2C_ISR_TXIS I2C_ISR_TXIS_Msk /*!< Transmit interrupt status */ +#define I2C_ISR_RXNE_Pos (2U) +#define I2C_ISR_RXNE_Msk (0x1UL << I2C_ISR_RXNE_Pos) /*!< 0x00000004 */ +#define I2C_ISR_RXNE I2C_ISR_RXNE_Msk /*!< Receive data register not empty */ +#define I2C_ISR_ADDR_Pos (3U) +#define I2C_ISR_ADDR_Msk (0x1UL << I2C_ISR_ADDR_Pos) /*!< 0x00000008 */ +#define I2C_ISR_ADDR I2C_ISR_ADDR_Msk /*!< Address matched (slave mode) */ +#define I2C_ISR_NACKF_Pos (4U) +#define I2C_ISR_NACKF_Msk (0x1UL << I2C_ISR_NACKF_Pos) /*!< 0x00000010 */ +#define I2C_ISR_NACKF I2C_ISR_NACKF_Msk /*!< NACK received flag */ +#define I2C_ISR_STOPF_Pos (5U) +#define I2C_ISR_STOPF_Msk (0x1UL << I2C_ISR_STOPF_Pos) /*!< 0x00000020 */ +#define I2C_ISR_STOPF I2C_ISR_STOPF_Msk /*!< STOP detection flag */ +#define I2C_ISR_TC_Pos (6U) +#define I2C_ISR_TC_Msk (0x1UL << I2C_ISR_TC_Pos) /*!< 0x00000040 */ +#define I2C_ISR_TC I2C_ISR_TC_Msk /*!< Transfer complete (master mode) */ +#define I2C_ISR_TCR_Pos (7U) +#define I2C_ISR_TCR_Msk (0x1UL << I2C_ISR_TCR_Pos) /*!< 0x00000080 */ +#define I2C_ISR_TCR I2C_ISR_TCR_Msk /*!< Transfer complete reload */ +#define I2C_ISR_BERR_Pos (8U) +#define I2C_ISR_BERR_Msk (0x1UL << I2C_ISR_BERR_Pos) /*!< 0x00000100 */ +#define I2C_ISR_BERR I2C_ISR_BERR_Msk /*!< Bus error */ +#define I2C_ISR_ARLO_Pos (9U) +#define I2C_ISR_ARLO_Msk (0x1UL << I2C_ISR_ARLO_Pos) /*!< 0x00000200 */ +#define I2C_ISR_ARLO I2C_ISR_ARLO_Msk /*!< Arbitration lost */ +#define I2C_ISR_OVR_Pos (10U) +#define I2C_ISR_OVR_Msk (0x1UL << I2C_ISR_OVR_Pos) /*!< 0x00000400 */ +#define I2C_ISR_OVR I2C_ISR_OVR_Msk /*!< Overrun/Underrun */ +#define I2C_ISR_PECERR_Pos (11U) +#define I2C_ISR_PECERR_Msk (0x1UL << I2C_ISR_PECERR_Pos) /*!< 0x00000800 */ +#define I2C_ISR_PECERR I2C_ISR_PECERR_Msk /*!< PEC error in reception */ +#define I2C_ISR_TIMEOUT_Pos (12U) +#define I2C_ISR_TIMEOUT_Msk (0x1UL << I2C_ISR_TIMEOUT_Pos) /*!< 0x00001000 */ +#define I2C_ISR_TIMEOUT I2C_ISR_TIMEOUT_Msk /*!< Timeout or Tlow detection flag */ +#define I2C_ISR_ALERT_Pos (13U) +#define I2C_ISR_ALERT_Msk (0x1UL << I2C_ISR_ALERT_Pos) /*!< 0x00002000 */ +#define I2C_ISR_ALERT I2C_ISR_ALERT_Msk /*!< SMBus alert */ +#define I2C_ISR_BUSY_Pos (15U) +#define I2C_ISR_BUSY_Msk (0x1UL << I2C_ISR_BUSY_Pos) /*!< 0x00008000 */ +#define I2C_ISR_BUSY I2C_ISR_BUSY_Msk /*!< Bus busy */ +#define I2C_ISR_DIR_Pos (16U) +#define I2C_ISR_DIR_Msk (0x1UL << I2C_ISR_DIR_Pos) /*!< 0x00010000 */ +#define I2C_ISR_DIR I2C_ISR_DIR_Msk /*!< Transfer direction (slave mode) */ +#define I2C_ISR_ADDCODE_Pos (17U) +#define I2C_ISR_ADDCODE_Msk (0x7FUL << I2C_ISR_ADDCODE_Pos) /*!< 0x00FE0000 */ +#define I2C_ISR_ADDCODE I2C_ISR_ADDCODE_Msk /*!< Address match code (slave mode) */ + +/****************** Bit definition for I2C_ICR register *********************/ +#define I2C_ICR_ADDRCF_Pos (3U) +#define I2C_ICR_ADDRCF_Msk (0x1UL << I2C_ICR_ADDRCF_Pos) /*!< 0x00000008 */ +#define I2C_ICR_ADDRCF I2C_ICR_ADDRCF_Msk /*!< Address matched clear flag */ +#define I2C_ICR_NACKCF_Pos (4U) +#define I2C_ICR_NACKCF_Msk (0x1UL << I2C_ICR_NACKCF_Pos) /*!< 0x00000010 */ +#define I2C_ICR_NACKCF I2C_ICR_NACKCF_Msk /*!< NACK clear flag */ +#define I2C_ICR_STOPCF_Pos (5U) +#define I2C_ICR_STOPCF_Msk (0x1UL << I2C_ICR_STOPCF_Pos) /*!< 0x00000020 */ +#define I2C_ICR_STOPCF I2C_ICR_STOPCF_Msk /*!< STOP detection clear flag */ +#define I2C_ICR_BERRCF_Pos (8U) +#define I2C_ICR_BERRCF_Msk (0x1UL << I2C_ICR_BERRCF_Pos) /*!< 0x00000100 */ +#define I2C_ICR_BERRCF I2C_ICR_BERRCF_Msk /*!< Bus error clear flag */ +#define I2C_ICR_ARLOCF_Pos (9U) +#define I2C_ICR_ARLOCF_Msk (0x1UL << I2C_ICR_ARLOCF_Pos) /*!< 0x00000200 */ +#define I2C_ICR_ARLOCF I2C_ICR_ARLOCF_Msk /*!< Arbitration lost clear flag */ +#define I2C_ICR_OVRCF_Pos (10U) +#define I2C_ICR_OVRCF_Msk (0x1UL << I2C_ICR_OVRCF_Pos) /*!< 0x00000400 */ +#define I2C_ICR_OVRCF I2C_ICR_OVRCF_Msk /*!< Overrun/Underrun clear flag */ +#define I2C_ICR_PECCF_Pos (11U) +#define I2C_ICR_PECCF_Msk (0x1UL << I2C_ICR_PECCF_Pos) /*!< 0x00000800 */ +#define I2C_ICR_PECCF I2C_ICR_PECCF_Msk /*!< PAC error clear flag */ +#define I2C_ICR_TIMOUTCF_Pos (12U) +#define I2C_ICR_TIMOUTCF_Msk (0x1UL << I2C_ICR_TIMOUTCF_Pos) /*!< 0x00001000 */ +#define I2C_ICR_TIMOUTCF I2C_ICR_TIMOUTCF_Msk /*!< Timeout clear flag */ +#define I2C_ICR_ALERTCF_Pos (13U) +#define I2C_ICR_ALERTCF_Msk (0x1UL << I2C_ICR_ALERTCF_Pos) /*!< 0x00002000 */ +#define I2C_ICR_ALERTCF I2C_ICR_ALERTCF_Msk /*!< Alert clear flag */ + +/****************** Bit definition for I2C_PECR register *********************/ +#define I2C_PECR_PEC_Pos (0U) +#define I2C_PECR_PEC_Msk (0xFFUL << I2C_PECR_PEC_Pos) /*!< 0x000000FF */ +#define I2C_PECR_PEC I2C_PECR_PEC_Msk /*!< PEC register */ + +/****************** Bit definition for I2C_RXDR register *********************/ +#define I2C_RXDR_RXDATA_Pos (0U) +#define I2C_RXDR_RXDATA_Msk (0xFFUL << I2C_RXDR_RXDATA_Pos) /*!< 0x000000FF */ +#define I2C_RXDR_RXDATA I2C_RXDR_RXDATA_Msk /*!< 8-bit receive data */ + +/****************** Bit definition for I2C_TXDR register *********************/ +#define I2C_TXDR_TXDATA_Pos (0U) +#define I2C_TXDR_TXDATA_Msk (0xFFUL << I2C_TXDR_TXDATA_Pos) /*!< 0x000000FF */ +#define I2C_TXDR_TXDATA I2C_TXDR_TXDATA_Msk /*!< 8-bit transmit data */ + +/******************************************************************************/ +/* */ +/* Independent WATCHDOG */ +/* */ +/******************************************************************************/ +/******************* Bit definition for IWDG_KR register ********************/ +#define IWDG_KR_KEY_Pos (0U) +#define IWDG_KR_KEY_Msk (0xFFFFUL << IWDG_KR_KEY_Pos) /*!< 0x0000FFFF */ +#define IWDG_KR_KEY IWDG_KR_KEY_Msk /*! +#define __I volatile // Note: Added for MikroE implementation. +#define __O __I // Note: Added for MikroE implementation. +#define __IO __I // Note: Added for MikroE implementation. + +/** @addtogroup Peripheral_registers_structures + * @{ + */ + +/** + * @brief Analog to Digital Converter + */ + +typedef struct +{ + __IO uint32_t ISR; /*!< ADC interrupt and status register, Address offset: 0x00 */ + __IO uint32_t IER; /*!< ADC interrupt enable register, Address offset: 0x04 */ + __IO uint32_t CR; /*!< ADC control register, Address offset: 0x08 */ + __IO uint32_t CFGR; /*!< ADC configuration register 1, Address offset: 0x0C */ + __IO uint32_t CFGR2; /*!< ADC configuration register 2, Address offset: 0x10 */ + __IO uint32_t SMPR1; /*!< ADC sampling time register 1, Address offset: 0x14 */ + __IO uint32_t SMPR2; /*!< ADC sampling time register 2, Address offset: 0x18 */ + uint32_t RESERVED1; /*!< Reserved, 0x1C */ + __IO uint32_t TR1; /*!< ADC analog watchdog 1 threshold register, Address offset: 0x20 */ + __IO uint32_t TR2; /*!< ADC analog watchdog 2 threshold register, Address offset: 0x24 */ + __IO uint32_t TR3; /*!< ADC analog watchdog 3 threshold register, Address offset: 0x28 */ + uint32_t RESERVED2; /*!< Reserved, 0x2C */ + __IO uint32_t SQR1; /*!< ADC group regular sequencer register 1, Address offset: 0x30 */ + __IO uint32_t SQR2; /*!< ADC group regular sequencer register 2, Address offset: 0x34 */ + __IO uint32_t SQR3; /*!< ADC group regular sequencer register 3, Address offset: 0x38 */ + __IO uint32_t SQR4; /*!< ADC group regular sequencer register 4, Address offset: 0x3C */ + __IO uint32_t DR; /*!< ADC group regular data register, Address offset: 0x40 */ + uint32_t RESERVED3; /*!< Reserved, 0x44 */ + uint32_t RESERVED4; /*!< Reserved, 0x48 */ + __IO uint32_t JSQR; /*!< ADC group injected sequencer register, Address offset: 0x4C */ + uint32_t RESERVED5[4]; /*!< Reserved, 0x50 - 0x5C */ + __IO uint32_t OFR1; /*!< ADC offset register 1, Address offset: 0x60 */ + __IO uint32_t OFR2; /*!< ADC offset register 2, Address offset: 0x64 */ + __IO uint32_t OFR3; /*!< ADC offset register 3, Address offset: 0x68 */ + __IO uint32_t OFR4; /*!< ADC offset register 4, Address offset: 0x6C */ + uint32_t RESERVED6[4]; /*!< Reserved, 0x70 - 0x7C */ + __IO uint32_t JDR1; /*!< ADC group injected rank 1 data register, Address offset: 0x80 */ + __IO uint32_t JDR2; /*!< ADC group injected rank 2 data register, Address offset: 0x84 */ + __IO uint32_t JDR3; /*!< ADC group injected rank 3 data register, Address offset: 0x88 */ + __IO uint32_t JDR4; /*!< ADC group injected rank 4 data register, Address offset: 0x8C */ + uint32_t RESERVED7[4]; /*!< Reserved, 0x090 - 0x09C */ + __IO uint32_t AWD2CR; /*!< ADC analog watchdog 1 configuration register, Address offset: 0xA0 */ + __IO uint32_t AWD3CR; /*!< ADC analog watchdog 3 Configuration Register, Address offset: 0xA4 */ + uint32_t RESERVED8; /*!< Reserved, 0x0A8 */ + uint32_t RESERVED9; /*!< Reserved, 0x0AC */ + __IO uint32_t DIFSEL; /*!< ADC differential mode selection register, Address offset: 0xB0 */ + __IO uint32_t CALFACT; /*!< ADC calibration factors, Address offset: 0xB4 */ + +} ADC_TypeDef; + +typedef struct +{ + __IO uint32_t CSR; /*!< ADC common status register, Address offset: ADC1 base address + 0x300 */ + uint32_t RESERVED; /*!< Reserved, Address offset: ADC1 base address + 0x304 */ + __IO uint32_t CCR; /*!< ADC common configuration register, Address offset: ADC1 base address + 0x308 */ + __IO uint32_t CDR; /*!< ADC common group regular data register Address offset: ADC1 base address + 0x30C */ +} ADC_Common_TypeDef; + + + + +/** + * @brief Comparator + */ + +typedef struct +{ + __IO uint32_t CSR; /*!< COMP control and status register, Address offset: 0x00 */ +} COMP_TypeDef; + +typedef struct +{ + __IO uint32_t CSR; /*!< COMP control and status register, used for bits common to several COMP instances, Address offset: 0x00 */ +} COMP_Common_TypeDef; + +/** + * @brief CRC calculation unit + */ + +typedef struct +{ + __IO uint32_t DR; /*!< CRC Data register, Address offset: 0x00 */ + __IO uint8_t IDR; /*!< CRC Independent data register, Address offset: 0x04 */ + uint8_t RESERVED0; /*!< Reserved, 0x05 */ + uint16_t RESERVED1; /*!< Reserved, 0x06 */ + __IO uint32_t CR; /*!< CRC Control register, Address offset: 0x08 */ + uint32_t RESERVED2; /*!< Reserved, 0x0C */ + __IO uint32_t INIT; /*!< Initial CRC value register, Address offset: 0x10 */ + __IO uint32_t POL; /*!< CRC polynomial register, Address offset: 0x14 */ +} CRC_TypeDef; + +/** + * @brief Clock Recovery System + */ +typedef struct +{ +__IO uint32_t CR; /*!< CRS ccontrol register, Address offset: 0x00 */ +__IO uint32_t CFGR; /*!< CRS configuration register, Address offset: 0x04 */ +__IO uint32_t ISR; /*!< CRS interrupt and status register, Address offset: 0x08 */ +__IO uint32_t ICR; /*!< CRS interrupt flag clear register, Address offset: 0x0C */ +} CRS_TypeDef; + + + +/** + * @brief Debug MCU + */ + +typedef struct +{ + __IO uint32_t IDCODE; /*!< MCU device ID code, Address offset: 0x00 */ + __IO uint32_t CR; /*!< Debug MCU configuration register, Address offset: 0x04 */ + __IO uint32_t APB1FZR1; /*!< Debug MCU APB1 freeze register 1, Address offset: 0x08 */ + __IO uint32_t APB1FZR2; /*!< Debug MCU APB1 freeze register 2, Address offset: 0x0C */ + __IO uint32_t APB2FZ; /*!< Debug MCU APB2 freeze register, Address offset: 0x10 */ +} DBGMCU_TypeDef; + + +/** + * @brief DMA Controller + */ + +typedef struct +{ + __IO uint32_t CCR; /*!< DMA channel x configuration register */ + __IO uint32_t CNDTR; /*!< DMA channel x number of data register */ + __IO uint32_t CPAR; /*!< DMA channel x peripheral address register */ + __IO uint32_t CMAR; /*!< DMA channel x memory address register */ +} DMA_Channel_TypeDef; + +typedef struct +{ + __IO uint32_t ISR; /*!< DMA interrupt status register, Address offset: 0x00 */ + __IO uint32_t IFCR; /*!< DMA interrupt flag clear register, Address offset: 0x04 */ +} DMA_TypeDef; + +typedef struct +{ + __IO uint32_t CSELR; /*!< DMA channel selection register */ +} DMA_Request_TypeDef; + +/* Legacy define */ +#define DMA_request_TypeDef DMA_Request_TypeDef + + +/** + * @brief External Interrupt/Event Controller + */ + +typedef struct +{ + __IO uint32_t IMR1; /*!< EXTI Interrupt mask register 1, Address offset: 0x00 */ + __IO uint32_t EMR1; /*!< EXTI Event mask register 1, Address offset: 0x04 */ + __IO uint32_t RTSR1; /*!< EXTI Rising trigger selection register 1, Address offset: 0x08 */ + __IO uint32_t FTSR1; /*!< EXTI Falling trigger selection register 1, Address offset: 0x0C */ + __IO uint32_t SWIER1; /*!< EXTI Software interrupt event register 1, Address offset: 0x10 */ + __IO uint32_t PR1; /*!< EXTI Pending register 1, Address offset: 0x14 */ + uint32_t RESERVED1; /*!< Reserved, 0x18 */ + uint32_t RESERVED2; /*!< Reserved, 0x1C */ + __IO uint32_t IMR2; /*!< EXTI Interrupt mask register 2, Address offset: 0x20 */ + __IO uint32_t EMR2; /*!< EXTI Event mask register 2, Address offset: 0x24 */ + __IO uint32_t RTSR2; /*!< EXTI Rising trigger selection register 2, Address offset: 0x28 */ + __IO uint32_t FTSR2; /*!< EXTI Falling trigger selection register 2, Address offset: 0x2C */ + __IO uint32_t SWIER2; /*!< EXTI Software interrupt event register 2, Address offset: 0x30 */ + __IO uint32_t PR2; /*!< EXTI Pending register 2, Address offset: 0x34 */ +} EXTI_TypeDef; + + +/** + * @brief Firewall + */ + +typedef struct +{ + __IO uint32_t CSSA; /*!< Code Segment Start Address register, Address offset: 0x00 */ + __IO uint32_t CSL; /*!< Code Segment Length register, Address offset: 0x04 */ + __IO uint32_t NVDSSA; /*!< NON volatile data Segment Start Address register, Address offset: 0x08 */ + __IO uint32_t NVDSL; /*!< NON volatile data Segment Length register, Address offset: 0x0C */ + __IO uint32_t VDSSA ; /*!< Volatile data Segment Start Address register, Address offset: 0x10 */ + __IO uint32_t VDSL ; /*!< Volatile data Segment Length register, Address offset: 0x14 */ + uint32_t RESERVED1; /*!< Reserved1, Address offset: 0x18 */ + uint32_t RESERVED2; /*!< Reserved2, Address offset: 0x1C */ + __IO uint32_t CR ; /*!< Configuration register, Address offset: 0x20 */ +} FIREWALL_TypeDef; + + +/** + * @brief FLASH Registers + */ + +typedef struct +{ + __IO uint32_t ACR; /*!< FLASH access control register, Address offset: 0x00 */ + __IO uint32_t PDKEYR; /*!< FLASH power down key register, Address offset: 0x04 */ + __IO uint32_t KEYR; /*!< FLASH key register, Address offset: 0x08 */ + __IO uint32_t OPTKEYR; /*!< FLASH option key register, Address offset: 0x0C */ + __IO uint32_t SR; /*!< FLASH status register, Address offset: 0x10 */ + __IO uint32_t CR; /*!< FLASH control register, Address offset: 0x14 */ + __IO uint32_t ECCR; /*!< FLASH ECC register, Address offset: 0x18 */ + __IO uint32_t RESERVED1; /*!< Reserved1, Address offset: 0x1C */ + __IO uint32_t OPTR; /*!< FLASH option register, Address offset: 0x20 */ + __IO uint32_t PCROP1SR; /*!< FLASH bank1 PCROP start address register, Address offset: 0x24 */ + __IO uint32_t PCROP1ER; /*!< FLASH bank1 PCROP end address register, Address offset: 0x28 */ + __IO uint32_t WRP1AR; /*!< FLASH bank1 WRP area A address register, Address offset: 0x2C */ + __IO uint32_t WRP1BR; /*!< FLASH bank1 WRP area B address register, Address offset: 0x30 */ +} FLASH_TypeDef; + + + +/** + * @brief General Purpose I/O + */ + +typedef struct +{ + __IO uint32_t MODER; /*!< GPIO port mode register, Address offset: 0x00 */ + __IO uint32_t OTYPER; /*!< GPIO port output type register, Address offset: 0x04 */ + __IO uint32_t OSPEEDR; /*!< GPIO port output speed register, Address offset: 0x08 */ + __IO uint32_t PUPDR; /*!< GPIO port pull-up/pull-down register, Address offset: 0x0C */ + __IO uint32_t IDR; /*!< GPIO port input data register, Address offset: 0x10 */ + __IO uint32_t ODR; /*!< GPIO port output data register, Address offset: 0x14 */ + __IO uint32_t BSRR; /*!< GPIO port bit set/reset register, Address offset: 0x18 */ + __IO uint32_t LCKR; /*!< GPIO port configuration lock register, Address offset: 0x1C */ + __IO uint32_t AFR[2]; /*!< GPIO alternate function registers, Address offset: 0x20-0x24 */ + __IO uint32_t BRR; /*!< GPIO Bit Reset register, Address offset: 0x28 */ + +} GPIO_TypeDef; + + +/** + * @brief Inter-integrated Circuit Interface + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< I2C Control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< I2C Control register 2, Address offset: 0x04 */ + __IO uint32_t OAR1; /*!< I2C Own address 1 register, Address offset: 0x08 */ + __IO uint32_t OAR2; /*!< I2C Own address 2 register, Address offset: 0x0C */ + __IO uint32_t TIMINGR; /*!< I2C Timing register, Address offset: 0x10 */ + __IO uint32_t TIMEOUTR; /*!< I2C Timeout register, Address offset: 0x14 */ + __IO uint32_t ISR; /*!< I2C Interrupt and status register, Address offset: 0x18 */ + __IO uint32_t ICR; /*!< I2C Interrupt clear register, Address offset: 0x1C */ + __IO uint32_t PECR; /*!< I2C PEC register, Address offset: 0x20 */ + __IO uint32_t RXDR; /*!< I2C Receive data register, Address offset: 0x24 */ + __IO uint32_t TXDR; /*!< I2C Transmit data register, Address offset: 0x28 */ +} I2C_TypeDef; + +/** + * @brief Independent WATCHDOG + */ + +typedef struct +{ + __IO uint32_t KR; /*!< IWDG Key register, Address offset: 0x00 */ + __IO uint32_t PR; /*!< IWDG Prescaler register, Address offset: 0x04 */ + __IO uint32_t RLR; /*!< IWDG Reload register, Address offset: 0x08 */ + __IO uint32_t SR; /*!< IWDG Status register, Address offset: 0x0C */ + __IO uint32_t WINR; /*!< IWDG Window register, Address offset: 0x10 */ +} IWDG_TypeDef; + +/** + * @brief LPTIMER + */ +typedef struct +{ + __IO uint32_t ISR; /*!< LPTIM Interrupt and Status register, Address offset: 0x00 */ + __IO uint32_t ICR; /*!< LPTIM Interrupt Clear register, Address offset: 0x04 */ + __IO uint32_t IER; /*!< LPTIM Interrupt Enable register, Address offset: 0x08 */ + __IO uint32_t CFGR; /*!< LPTIM Configuration register, Address offset: 0x0C */ + __IO uint32_t CR; /*!< LPTIM Control register, Address offset: 0x10 */ + __IO uint32_t CMP; /*!< LPTIM Compare register, Address offset: 0x14 */ + __IO uint32_t ARR; /*!< LPTIM Autoreload register, Address offset: 0x18 */ + __IO uint32_t CNT; /*!< LPTIM Counter register, Address offset: 0x1C */ + __IO uint32_t OR; /*!< LPTIM Option register, Address offset: 0x20 */ + __IO uint32_t RESERVED; /*!< Reserved, Address offset: 0x24 */ + __IO uint32_t RCR; /*!< LPTIM repetition counter register, Address offset: 0x28 */ +} LPTIM_TypeDef; + +/** + * @brief Operational Amplifier (OPAMP) + */ + +typedef struct +{ + __IO uint32_t CSR; /*!< OPAMP control/status register, Address offset: 0x00 */ + __IO uint32_t OTR; /*!< OPAMP offset trimming register for normal mode, Address offset: 0x04 */ + __IO uint32_t LPOTR; /*!< OPAMP offset trimming register for low power mode, Address offset: 0x08 */ +} OPAMP_TypeDef; + +typedef struct +{ + __IO uint32_t CSR; /*!< OPAMP control/status register, used for bits common to several OPAMP instances, Address offset: 0x00 */ +} OPAMP_Common_TypeDef; + +/** + * @brief Power Control + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< PWR power control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< PWR power control register 2, Address offset: 0x04 */ + __IO uint32_t CR3; /*!< PWR power control register 3, Address offset: 0x08 */ + __IO uint32_t CR4; /*!< PWR power control register 4, Address offset: 0x0C */ + __IO uint32_t SR1; /*!< PWR power status register 1, Address offset: 0x10 */ + __IO uint32_t SR2; /*!< PWR power status register 2, Address offset: 0x14 */ + __IO uint32_t SCR; /*!< PWR power status reset register, Address offset: 0x18 */ + uint32_t RESERVED; /*!< Reserved, Address offset: 0x1C */ + __IO uint32_t PUCRA; /*!< Pull_up control register of portA, Address offset: 0x20 */ + __IO uint32_t PDCRA; /*!< Pull_Down control register of portA, Address offset: 0x24 */ + __IO uint32_t PUCRB; /*!< Pull_up control register of portB, Address offset: 0x28 */ + __IO uint32_t PDCRB; /*!< Pull_Down control register of portB, Address offset: 0x2C */ + __IO uint32_t PUCRC; /*!< Pull_up control register of portC, Address offset: 0x30 */ + __IO uint32_t PDCRC; /*!< Pull_Down control register of portC, Address offset: 0x34 */ + __IO uint32_t PUCRD; /*!< Pull_up control register of portD, Address offset: 0x38 */ + __IO uint32_t PDCRD; /*!< Pull_Down control register of portD, Address offset: 0x3C */ + __IO uint32_t PUCRE; /*!< Pull_up control register of portE, Address offset: 0x40 */ + __IO uint32_t PDCRE; /*!< Pull_Down control register of portE, Address offset: 0x44 */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x48 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x4C */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x50 */ + uint32_t RESERVED4; /*!< Reserved, Address offset: 0x54 */ + __IO uint32_t PUCRH; /*!< Pull_up control register of portH, Address offset: 0x58 */ + __IO uint32_t PDCRH; /*!< Pull_Down control register of portH, Address offset: 0x5C */ +} PWR_TypeDef; + + +/** + * @brief QUAD Serial Peripheral Interface + */ + +typedef struct +{ + __IO uint32_t CR; /*!< QUADSPI Control register, Address offset: 0x00 */ + __IO uint32_t DCR; /*!< QUADSPI Device Configuration register, Address offset: 0x04 */ + __IO uint32_t SR; /*!< QUADSPI Status register, Address offset: 0x08 */ + __IO uint32_t FCR; /*!< QUADSPI Flag Clear register, Address offset: 0x0C */ + __IO uint32_t DLR; /*!< QUADSPI Data Length register, Address offset: 0x10 */ + __IO uint32_t CCR; /*!< QUADSPI Communication Configuration register, Address offset: 0x14 */ + __IO uint32_t AR; /*!< QUADSPI Address register, Address offset: 0x18 */ + __IO uint32_t ABR; /*!< QUADSPI Alternate Bytes register, Address offset: 0x1C */ + __IO uint32_t DR; /*!< QUADSPI Data register, Address offset: 0x20 */ + __IO uint32_t PSMKR; /*!< QUADSPI Polling Status Mask register, Address offset: 0x24 */ + __IO uint32_t PSMAR; /*!< QUADSPI Polling Status Match register, Address offset: 0x28 */ + __IO uint32_t PIR; /*!< QUADSPI Polling Interval register, Address offset: 0x2C */ + __IO uint32_t LPTR; /*!< QUADSPI Low Power Timeout register, Address offset: 0x30 */ +} QUADSPI_TypeDef; + + +/** + * @brief Reset and Clock Control + */ + +typedef struct +{ + __IO uint32_t CR; /*!< RCC clock control register, Address offset: 0x00 */ + __IO uint32_t ICSCR; /*!< RCC internal clock sources calibration register, Address offset: 0x04 */ + __IO uint32_t CFGR; /*!< RCC clock configuration register, Address offset: 0x08 */ + __IO uint32_t PLLCFGR; /*!< RCC system PLL configuration register, Address offset: 0x0C */ + uint32_t RESERVED8; /*!< Reserved, Address offset: 0x10 */ + uint32_t RESERVED; /*!< Reserved, Address offset: 0x14 */ + __IO uint32_t CIER; /*!< RCC clock interrupt enable register, Address offset: 0x18 */ + __IO uint32_t CIFR; /*!< RCC clock interrupt flag register, Address offset: 0x1C */ + __IO uint32_t CICR; /*!< RCC clock interrupt clear register, Address offset: 0x20 */ + uint32_t RESERVED0; /*!< Reserved, Address offset: 0x24 */ + __IO uint32_t AHB1RSTR; /*!< RCC AHB1 peripheral reset register, Address offset: 0x28 */ + __IO uint32_t AHB2RSTR; /*!< RCC AHB2 peripheral reset register, Address offset: 0x2C */ + __IO uint32_t AHB3RSTR; /*!< RCC AHB3 peripheral reset register, Address offset: 0x30 */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x34 */ + __IO uint32_t APB1RSTR1; /*!< RCC APB1 peripheral reset register 1, Address offset: 0x38 */ + __IO uint32_t APB1RSTR2; /*!< RCC APB1 peripheral reset register 2, Address offset: 0x3C */ + __IO uint32_t APB2RSTR; /*!< RCC APB2 peripheral reset register, Address offset: 0x40 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x44 */ + __IO uint32_t AHB1ENR; /*!< RCC AHB1 peripheral clocks enable register, Address offset: 0x48 */ + __IO uint32_t AHB2ENR; /*!< RCC AHB2 peripheral clocks enable register, Address offset: 0x4C */ + __IO uint32_t AHB3ENR; /*!< RCC AHB3 peripheral clocks enable register, Address offset: 0x50 */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x54 */ + __IO uint32_t APB1ENR1; /*!< RCC APB1 peripheral clocks enable register 1, Address offset: 0x58 */ + __IO uint32_t APB1ENR2; /*!< RCC APB1 peripheral clocks enable register 2, Address offset: 0x5C */ + __IO uint32_t APB2ENR; /*!< RCC APB2 peripheral clocks enable register, Address offset: 0x60 */ + uint32_t RESERVED4; /*!< Reserved, Address offset: 0x64 */ + __IO uint32_t AHB1SMENR; /*!< RCC AHB1 peripheral clocks enable in sleep and stop modes register, Address offset: 0x68 */ + __IO uint32_t AHB2SMENR; /*!< RCC AHB2 peripheral clocks enable in sleep and stop modes register, Address offset: 0x6C */ + __IO uint32_t AHB3SMENR; /*!< RCC AHB3 peripheral clocks enable in sleep and stop modes register, Address offset: 0x70 */ + uint32_t RESERVED5; /*!< Reserved, Address offset: 0x74 */ + __IO uint32_t APB1SMENR1; /*!< RCC APB1 peripheral clocks enable in sleep mode and stop modes register 1, Address offset: 0x78 */ + __IO uint32_t APB1SMENR2; /*!< RCC APB1 peripheral clocks enable in sleep mode and stop modes register 2, Address offset: 0x7C */ + __IO uint32_t APB2SMENR; /*!< RCC APB2 peripheral clocks enable in sleep mode and stop modes register, Address offset: 0x80 */ + uint32_t RESERVED6; /*!< Reserved, Address offset: 0x84 */ + __IO uint32_t CCIPR; /*!< RCC peripherals independent clock configuration register, Address offset: 0x88 */ + uint32_t RESERVED7; /*!< Reserved, Address offset: 0x8C */ + __IO uint32_t BDCR; /*!< RCC backup domain control register, Address offset: 0x90 */ + __IO uint32_t CSR; /*!< RCC clock control & status register, Address offset: 0x94 */ + __IO uint32_t CRRCR; /*!< RCC clock recovery RC register, Address offset: 0x98 */ +} RCC_TypeDef; + +/** + * @brief Real-Time Clock + */ + +typedef struct +{ + __IO uint32_t TR; /*!< RTC time register, Address offset: 0x00 */ + __IO uint32_t DR; /*!< RTC date register, Address offset: 0x04 */ + __IO uint32_t SSR; /*!< RTC sub second register, Address offset: 0x08 */ + __IO uint32_t ICSR; /*!< RTC initialization control and status register, Address offset: 0x0C */ + __IO uint32_t PRER; /*!< RTC prescaler register, Address offset: 0x10 */ + __IO uint32_t WUTR; /*!< RTC wakeup timer register, Address offset: 0x14 */ + __IO uint32_t CR; /*!< RTC control register, Address offset: 0x18 */ + uint32_t RESERVED0; /*!< Reserved, Address offset: 0x1C */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x20 */ + __IO uint32_t WPR; /*!< RTC write protection register, Address offset: 0x24 */ + __IO uint32_t CALR; /*!< RTC calibration register, Address offset: 0x28 */ + __IO uint32_t SHIFTR; /*!< RTC shift control register, Address offset: 0x2C */ + __IO uint32_t TSTR; /*!< RTC time stamp time register, Address offset: 0x30 */ + __IO uint32_t TSDR; /*!< RTC time stamp date register, Address offset: 0x34 */ + __IO uint32_t TSSSR; /*!< RTC time-stamp sub second register, Address offset: 0x38 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x3C */ + __IO uint32_t ALRMAR; /*!< RTC alarm A register, Address offset: 0x40 */ + __IO uint32_t ALRMASSR; /*!< RTC alarm A sub second register, Address offset: 0x44 */ + __IO uint32_t ALRMBR; /*!< RTC alarm B register, Address offset: 0x48 */ + __IO uint32_t ALRMBSSR; /*!< RTC alarm B sub second register, Address offset: 0x4C */ + __IO uint32_t SR; /*!< RTC Status register, Address offset: 0x50 */ + __IO uint32_t MISR; /*!< RTC masked interrupt status register, Address offset: 0x54 */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x58 */ + __IO uint32_t SCR; /*!< RTC status Clear register, Address offset: 0x5C */ +} RTC_TypeDef; + +/** + * @brief Tamper and backup registers + */ +typedef struct +{ + __IO uint32_t CR1; /*!< TAMP configuration register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< TAMP configuration register 2, Address offset: 0x04 */ + uint32_t RESERVED0; /*!< Reserved, Address offset: 0x08 */ + __IO uint32_t FLTCR; /*!< TAMP filter control register, Address offset: 0x0C */ + uint32_t RESERVED1[7];/*!< Reserved, Address offset: 0x10 -- 0x28 */ + __IO uint32_t IER; /*!< TAMP interrupt enable register, Address offset: 0x2C */ + __IO uint32_t SR; /*!< TAMP status register, Address offset: 0x30 */ + __IO uint32_t MISR; /*!< TAMP masked interrupt status register, Address offset: 0x34 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x38 */ + __IO uint32_t SCR; /*!< TAMP status clear register, Address offset: 0x3C */ + uint32_t RESERVED3[48];/*!< Reserved, Address offset: 0x40 -- 0xFC */ + __IO uint32_t BKP0R; /*!< TAMP backup register 0, Address offset: 0x100 */ + __IO uint32_t BKP1R; /*!< TAMP backup register 1, Address offset: 0x104 */ + __IO uint32_t BKP2R; /*!< TAMP backup register 2, Address offset: 0x108 */ + __IO uint32_t BKP3R; /*!< TAMP backup register 3, Address offset: 0x10C */ + __IO uint32_t BKP4R; /*!< TAMP backup register 4, Address offset: 0x110 */ + __IO uint32_t BKP5R; /*!< TAMP backup register 5, Address offset: 0x114 */ + __IO uint32_t BKP6R; /*!< TAMP backup register 6, Address offset: 0x118 */ + __IO uint32_t BKP7R; /*!< TAMP backup register 7, Address offset: 0x11C */ + __IO uint32_t BKP8R; /*!< TAMP backup register 8, Address offset: 0x120 */ + __IO uint32_t BKP9R; /*!< TAMP backup register 9, Address offset: 0x124 */ + __IO uint32_t BKP10R; /*!< TAMP backup register 10, Address offset: 0x128 */ + __IO uint32_t BKP11R; /*!< TAMP backup register 11, Address offset: 0x12C */ + __IO uint32_t BKP12R; /*!< TAMP backup register 12, Address offset: 0x130 */ + __IO uint32_t BKP13R; /*!< TAMP backup register 13, Address offset: 0x134 */ + __IO uint32_t BKP14R; /*!< TAMP backup register 14, Address offset: 0x138 */ + __IO uint32_t BKP15R; /*!< TAMP backup register 15, Address offset: 0x13C */ + __IO uint32_t BKP16R; /*!< TAMP backup register 16, Address offset: 0x140 */ + __IO uint32_t BKP17R; /*!< TAMP backup register 17, Address offset: 0x144 */ + __IO uint32_t BKP18R; /*!< TAMP backup register 18, Address offset: 0x148 */ + __IO uint32_t BKP19R; /*!< TAMP backup register 19, Address offset: 0x14C */ + __IO uint32_t BKP20R; /*!< TAMP backup register 20, Address offset: 0x150 */ + __IO uint32_t BKP21R; /*!< TAMP backup register 21, Address offset: 0x154 */ + __IO uint32_t BKP22R; /*!< TAMP backup register 22, Address offset: 0x158 */ + __IO uint32_t BKP23R; /*!< TAMP backup register 23, Address offset: 0x15C */ + __IO uint32_t BKP24R; /*!< TAMP backup register 24, Address offset: 0x160 */ + __IO uint32_t BKP25R; /*!< TAMP backup register 25, Address offset: 0x164 */ + __IO uint32_t BKP26R; /*!< TAMP backup register 26, Address offset: 0x168 */ + __IO uint32_t BKP27R; /*!< TAMP backup register 27, Address offset: 0x16C */ + __IO uint32_t BKP28R; /*!< TAMP backup register 28, Address offset: 0x170 */ + __IO uint32_t BKP29R; /*!< TAMP backup register 29, Address offset: 0x174 */ + __IO uint32_t BKP30R; /*!< TAMP backup register 30, Address offset: 0x178 */ + __IO uint32_t BKP31R; /*!< TAMP backup register 31, Address offset: 0x17C */ +} TAMP_TypeDef; + + + +/** + * @brief Serial Peripheral Interface + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< SPI Control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< SPI Control register 2, Address offset: 0x04 */ + __IO uint32_t SR; /*!< SPI Status register, Address offset: 0x08 */ + __IO uint32_t DR; /*!< SPI data register, Address offset: 0x0C */ + __IO uint32_t CRCPR; /*!< SPI CRC polynomial register, Address offset: 0x10 */ + __IO uint32_t RXCRCR; /*!< SPI Rx CRC register, Address offset: 0x14 */ + __IO uint32_t TXCRCR; /*!< SPI Tx CRC register, Address offset: 0x18 */ +} SPI_TypeDef; + + +/** + * @brief System configuration controller + */ + +typedef struct +{ + __IO uint32_t MEMRMP; /*!< SYSCFG memory remap register, Address offset: 0x00 */ + __IO uint32_t CFGR1; /*!< SYSCFG configuration register 1, Address offset: 0x04 */ + __IO uint32_t EXTICR[4]; /*!< SYSCFG external interrupt configuration registers, Address offset: 0x08-0x14 */ + __IO uint32_t SCSR; /*!< SYSCFG SRAM2 control and status register, Address offset: 0x18 */ + __IO uint32_t CFGR2; /*!< SYSCFG configuration register 2, Address offset: 0x1C */ + __IO uint32_t SWPR; /*!< SYSCFG SRAM2 write protection register, Address offset: 0x20 */ + __IO uint32_t SKR; /*!< SYSCFG SRAM2 key register, Address offset: 0x24 */ +} SYSCFG_TypeDef; + + +/** + * @brief TIM + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< TIM control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */ + __IO uint32_t SMCR; /*!< TIM slave mode control register, Address offset: 0x08 */ + __IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */ + __IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */ + __IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */ + __IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */ + __IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */ + __IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */ + __IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */ + __IO uint32_t PSC; /*!< TIM prescaler, Address offset: 0x28 */ + __IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */ + __IO uint32_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */ + __IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */ + __IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */ + __IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C */ + __IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */ + __IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */ + __IO uint32_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */ + __IO uint32_t DMAR; /*!< TIM DMA address for full transfer, Address offset: 0x4C */ + __IO uint32_t OR1; /*!< TIM option register 1, Address offset: 0x50 */ + __IO uint32_t CCMR3; /*!< TIM capture/compare mode register 3, Address offset: 0x54 */ + __IO uint32_t CCR5; /*!< TIM capture/compare register5, Address offset: 0x58 */ + __IO uint32_t CCR6; /*!< TIM capture/compare register6, Address offset: 0x5C */ + __IO uint32_t OR2; /*!< TIM option register 2, Address offset: 0x60 */ + __IO uint32_t OR3; /*!< TIM option register 3, Address offset: 0x64 */ +} TIM_TypeDef; + + +/** + * @brief Touch Sensing Controller (TSC) + */ + +typedef struct +{ + __IO uint32_t CR; /*!< TSC control register, Address offset: 0x00 */ + __IO uint32_t IER; /*!< TSC interrupt enable register, Address offset: 0x04 */ + __IO uint32_t ICR; /*!< TSC interrupt clear register, Address offset: 0x08 */ + __IO uint32_t ISR; /*!< TSC interrupt status register, Address offset: 0x0C */ + __IO uint32_t IOHCR; /*!< TSC I/O hysteresis control register, Address offset: 0x10 */ + uint32_t RESERVED1; /*!< Reserved, Address offset: 0x14 */ + __IO uint32_t IOASCR; /*!< TSC I/O analog switch control register, Address offset: 0x18 */ + uint32_t RESERVED2; /*!< Reserved, Address offset: 0x1C */ + __IO uint32_t IOSCR; /*!< TSC I/O sampling control register, Address offset: 0x20 */ + uint32_t RESERVED3; /*!< Reserved, Address offset: 0x24 */ + __IO uint32_t IOCCR; /*!< TSC I/O channel control register, Address offset: 0x28 */ + uint32_t RESERVED4; /*!< Reserved, Address offset: 0x2C */ + __IO uint32_t IOGCSR; /*!< TSC I/O group control status register, Address offset: 0x30 */ + __IO uint32_t IOGXCR[7]; /*!< TSC I/O group x counter register, Address offset: 0x34-4C */ +} TSC_TypeDef; + +/** + * @brief Universal Synchronous Asynchronous Receiver Transmitter + */ + +typedef struct +{ + __IO uint32_t CR1; /*!< USART Control register 1, Address offset: 0x00 */ + __IO uint32_t CR2; /*!< USART Control register 2, Address offset: 0x04 */ + __IO uint32_t CR3; /*!< USART Control register 3, Address offset: 0x08 */ + __IO uint32_t BRR; /*!< USART Baud rate register, Address offset: 0x0C */ + __IO uint16_t GTPR; /*!< USART Guard time and prescaler register, Address offset: 0x10 */ + uint16_t RESERVED2; /*!< Reserved, 0x12 */ + __IO uint32_t RTOR; /*!< USART Receiver Time Out register, Address offset: 0x14 */ + __IO uint16_t RQR; /*!< USART Request register, Address offset: 0x18 */ + uint16_t RESERVED3; /*!< Reserved, 0x1A */ + __IO uint32_t ISR; /*!< USART Interrupt and status register, Address offset: 0x1C */ + __IO uint32_t ICR; /*!< USART Interrupt flag Clear register, Address offset: 0x20 */ + __IO uint16_t RDR; /*!< USART Receive Data register, Address offset: 0x24 */ + uint16_t RESERVED4; /*!< Reserved, 0x26 */ + __IO uint16_t TDR; /*!< USART Transmit Data register, Address offset: 0x28 */ + uint16_t RESERVED5; /*!< Reserved, 0x2A */ +} USART_TypeDef; + +/** + * @brief Universal Serial Bus Full Speed Device + */ + +typedef struct +{ + __IO uint16_t EP0R; /*!< USB Endpoint 0 register, Address offset: 0x00 */ + __IO uint16_t RESERVED0; /*!< Reserved */ + __IO uint16_t EP1R; /*!< USB Endpoint 1 register, Address offset: 0x04 */ + __IO uint16_t RESERVED1; /*!< Reserved */ + __IO uint16_t EP2R; /*!< USB Endpoint 2 register, Address offset: 0x08 */ + __IO uint16_t RESERVED2; /*!< Reserved */ + __IO uint16_t EP3R; /*!< USB Endpoint 3 register, Address offset: 0x0C */ + __IO uint16_t RESERVED3; /*!< Reserved */ + __IO uint16_t EP4R; /*!< USB Endpoint 4 register, Address offset: 0x10 */ + __IO uint16_t RESERVED4; /*!< Reserved */ + __IO uint16_t EP5R; /*!< USB Endpoint 5 register, Address offset: 0x14 */ + __IO uint16_t RESERVED5; /*!< Reserved */ + __IO uint16_t EP6R; /*!< USB Endpoint 6 register, Address offset: 0x18 */ + __IO uint16_t RESERVED6; /*!< Reserved */ + __IO uint16_t EP7R; /*!< USB Endpoint 7 register, Address offset: 0x1C */ + __IO uint16_t RESERVED7[17]; /*!< Reserved */ + __IO uint16_t CNTR; /*!< Control register, Address offset: 0x40 */ + __IO uint16_t RESERVED8; /*!< Reserved */ + __IO uint16_t ISTR; /*!< Interrupt status register, Address offset: 0x44 */ + __IO uint16_t RESERVED9; /*!< Reserved */ + __IO uint16_t FNR; /*!< Frame number register, Address offset: 0x48 */ + __IO uint16_t RESERVEDA; /*!< Reserved */ + __IO uint16_t DADDR; /*!< Device address register, Address offset: 0x4C */ + __IO uint16_t RESERVEDB; /*!< Reserved */ + __IO uint16_t BTABLE; /*!< Buffer Table address register, Address offset: 0x50 */ + __IO uint16_t RESERVEDC; /*!< Reserved */ + __IO uint16_t LPMCSR; /*!< LPM Control and Status register, Address offset: 0x54 */ + __IO uint16_t RESERVEDD; /*!< Reserved */ + __IO uint16_t BCDR; /*!< Battery Charging detector register, Address offset: 0x58 */ + __IO uint16_t RESERVEDE; /*!< Reserved */ +} USB_TypeDef; + + +/** + * @brief Window WATCHDOG + */ + +typedef struct +{ + __IO uint32_t CR; /*!< WWDG Control register, Address offset: 0x00 */ + __IO uint32_t CFR; /*!< WWDG Configuration register, Address offset: 0x04 */ + __IO uint32_t SR; /*!< WWDG Status register, Address offset: 0x08 */ +} WWDG_TypeDef; + +/** + * @brief AES hardware accelerator + */ + +typedef struct +{ + __IO uint32_t CR; /*!< AES control register, Address offset: 0x00 */ + __IO uint32_t SR; /*!< AES status register, Address offset: 0x04 */ + __IO uint32_t DINR; /*!< AES data input register, Address offset: 0x08 */ + __IO uint32_t DOUTR; /*!< AES data output register, Address offset: 0x0C */ + __IO uint32_t KEYR0; /*!< AES key register 0, Address offset: 0x10 */ + __IO uint32_t KEYR1; /*!< AES key register 1, Address offset: 0x14 */ + __IO uint32_t KEYR2; /*!< AES key register 2, Address offset: 0x18 */ + __IO uint32_t KEYR3; /*!< AES key register 3, Address offset: 0x1C */ + __IO uint32_t IVR0; /*!< AES initialization vector register 0, Address offset: 0x20 */ + __IO uint32_t IVR1; /*!< AES initialization vector register 1, Address offset: 0x24 */ + __IO uint32_t IVR2; /*!< AES initialization vector register 2, Address offset: 0x28 */ + __IO uint32_t IVR3; /*!< AES initialization vector register 3, Address offset: 0x2C */ + __IO uint32_t KEYR4; /*!< AES key register 4, Address offset: 0x30 */ + __IO uint32_t KEYR5; /*!< AES key register 5, Address offset: 0x34 */ + __IO uint32_t KEYR6; /*!< AES key register 6, Address offset: 0x38 */ + __IO uint32_t KEYR7; /*!< AES key register 7, Address offset: 0x3C */ + __IO uint32_t SUSP0R; /*!< AES Suspend register 0, Address offset: 0x40 */ + __IO uint32_t SUSP1R; /*!< AES Suspend register 1, Address offset: 0x44 */ + __IO uint32_t SUSP2R; /*!< AES Suspend register 2, Address offset: 0x48 */ + __IO uint32_t SUSP3R; /*!< AES Suspend register 3, Address offset: 0x4C */ + __IO uint32_t SUSP4R; /*!< AES Suspend register 4, Address offset: 0x50 */ + __IO uint32_t SUSP5R; /*!< AES Suspend register 5, Address offset: 0x54 */ + __IO uint32_t SUSP6R; /*!< AES Suspend register 6, Address offset: 0x58 */ + __IO uint32_t SUSP7R; /*!< AES Suspend register 7, Address offset: 0x6C */ +} AES_TypeDef; + +/** + * @brief RNG + */ + +typedef struct +{ + __IO uint32_t CR; /*!< RNG control register, Address offset: 0x00 */ + __IO uint32_t SR; /*!< RNG status register, Address offset: 0x04 */ + __IO uint32_t DR; /*!< RNG data register, Address offset: 0x08 */ +} RNG_TypeDef; + +/** + * @} + */ + +/** @addtogroup Peripheral_memory_map + * @{ + */ +#define FLASH_BASE (0x08000000UL) /*!< FLASH(up to 128 KB) base address */ +#define FLASH_END (0x0801FFFFUL) /*!< FLASH END address */ +#define FLASH_BANK1_END (0x0801FFFFUL) /*!< FLASH END address of bank1 */ +#define SRAM1_BASE (0x20000000UL) /*!< SRAM1(up to 32 KB) base address */ +#define SRAM2_BASE (0x10000000UL) /*!< SRAM2(8 KB) base address */ +#define PERIPH_BASE (0x40000000UL) /*!< Peripheral base address */ +#define QSPI_BASE (0x90000000UL) /*!< QUADSPI memories accessible over AHB base address */ + +#define QSPI_R_BASE (0xA0001000UL) /*!< QUADSPI control registers base address */ +#define SRAM1_BB_BASE (0x22000000UL) /*!< SRAM1(96 KB) base address in the bit-band region */ +#define PERIPH_BB_BASE (0x42000000UL) /*!< Peripheral base address in the bit-band region */ + +/* Legacy defines */ +#define SRAM_BASE SRAM1_BASE +#define SRAM_BB_BASE SRAM1_BB_BASE + +#define SRAM1_SIZE_MAX (0x00008000UL) /*!< maximum SRAM1 size (up to 32 KBytes) */ +#define SRAM2_SIZE (0x00002000UL) /*!< SRAM2 size (8 KBytes) */ + +#define FLASH_SIZE_DATA_REGISTER (0x1FFF75E0UL) + +#define FLASH_SIZE (((((*((uint32_t *)FLASH_SIZE_DATA_REGISTER)) & (0x0000FFFFU)) == 0x0000FFFFU)) ? (0x80U << 10U) : \ + (((*((uint32_t *)FLASH_SIZE_DATA_REGISTER)) & (0x0000FFFFU)) << 10U)) + +/*!< Peripheral memory map */ +#define APB1PERIPH_BASE PERIPH_BASE +#define APB2PERIPH_BASE (PERIPH_BASE + 0x00010000UL) +#define AHB1PERIPH_BASE (PERIPH_BASE + 0x00020000UL) +#define AHB2PERIPH_BASE (PERIPH_BASE + 0x08000000UL) + + +/*!< APB1 peripherals */ +#define TIM2_BASE (APB1PERIPH_BASE + 0x0000UL) +#define TIM6_BASE (APB1PERIPH_BASE + 0x1000UL) +#define RTC_BASE (APB1PERIPH_BASE + 0x2800UL) +#define WWDG_BASE (APB1PERIPH_BASE + 0x2C00UL) +#define IWDG_BASE (APB1PERIPH_BASE + 0x3000UL) +#define TAMP_BASE (APB1PERIPH_BASE + 0x3400U) +#define SPI2_BASE (APB1PERIPH_BASE + 0x3800UL) +#define USART2_BASE (APB1PERIPH_BASE + 0x4400UL) +#define USART3_BASE (APB1PERIPH_BASE + 0x4800UL) +#define I2C1_BASE (APB1PERIPH_BASE + 0x5400UL) +#define I2C2_BASE (APB1PERIPH_BASE + 0x5800UL) +#define I2C3_BASE (APB1PERIPH_BASE + 0x5C00UL) +#define CRS_BASE (APB1PERIPH_BASE + 0x6000UL) +#define USB_BASE (APB1PERIPH_BASE + 0x6800UL) /*!< USB_IP Peripheral Registers base address */ +#define USB_PMAADDR (APB1PERIPH_BASE + 0x6C00UL) /*!< USB_IP Packet Memory Area base address */ +#define PWR_BASE (APB1PERIPH_BASE + 0x7000UL) +#define OPAMP_BASE (APB1PERIPH_BASE + 0x7800UL) +#define OPAMP1_BASE (APB1PERIPH_BASE + 0x7800UL) +#define LPTIM1_BASE (APB1PERIPH_BASE + 0x7C00UL) +#define LPUART1_BASE (APB1PERIPH_BASE + 0x8000UL) +#define LPTIM2_BASE (APB1PERIPH_BASE + 0x9400UL) + + +/*!< APB2 peripherals */ +#define SYSCFG_BASE (APB2PERIPH_BASE + 0x0000UL) +#define COMP1_BASE (APB2PERIPH_BASE + 0x0200UL) +#define EXTI_BASE (APB2PERIPH_BASE + 0x0400UL) +#define FIREWALL_BASE (APB2PERIPH_BASE + 0x1C00UL) +#define TIM1_BASE (APB2PERIPH_BASE + 0x2C00UL) +#define SPI1_BASE (APB2PERIPH_BASE + 0x3000UL) +#define USART1_BASE (APB2PERIPH_BASE + 0x3800UL) +#define TIM15_BASE (APB2PERIPH_BASE + 0x4000UL) +#define TIM16_BASE (APB2PERIPH_BASE + 0x4400UL) + +/*!< AHB1 peripherals */ +#define DMA1_BASE (AHB1PERIPH_BASE) +#define DMA2_BASE (AHB1PERIPH_BASE + 0x0400UL) +#define RCC_BASE (AHB1PERIPH_BASE + 0x1000UL) +#define FLASH_R_BASE (AHB1PERIPH_BASE + 0x2000UL) +#define CRC_BASE (AHB1PERIPH_BASE + 0x3000UL) +#define TSC_BASE (AHB1PERIPH_BASE + 0x4000UL) + + +#define DMA1_Channel1_BASE (DMA1_BASE + 0x0008UL) +#define DMA1_Channel2_BASE (DMA1_BASE + 0x001CUL) +#define DMA1_Channel3_BASE (DMA1_BASE + 0x0030UL) +#define DMA1_Channel4_BASE (DMA1_BASE + 0x0044UL) +#define DMA1_Channel5_BASE (DMA1_BASE + 0x0058UL) +#define DMA1_Channel6_BASE (DMA1_BASE + 0x006CUL) +#define DMA1_Channel7_BASE (DMA1_BASE + 0x0080UL) +#define DMA1_CSELR_BASE (DMA1_BASE + 0x00A8UL) + + +#define DMA2_Channel1_BASE (DMA2_BASE + 0x0008UL) +#define DMA2_Channel2_BASE (DMA2_BASE + 0x001CUL) +#define DMA2_Channel3_BASE (DMA2_BASE + 0x0030UL) +#define DMA2_Channel4_BASE (DMA2_BASE + 0x0044UL) +#define DMA2_Channel5_BASE (DMA2_BASE + 0x0058UL) +#define DMA2_Channel6_BASE (DMA2_BASE + 0x006CUL) +#define DMA2_Channel7_BASE (DMA2_BASE + 0x0080UL) +#define DMA2_CSELR_BASE (DMA2_BASE + 0x00A8UL) + + +/*!< AHB2 peripherals */ +#define GPIOA_BASE (AHB2PERIPH_BASE + 0x0000UL) +#define GPIOB_BASE (AHB2PERIPH_BASE + 0x0400UL) +#define GPIOC_BASE (AHB2PERIPH_BASE + 0x0800UL) +#define GPIOD_BASE (AHB2PERIPH_BASE + 0x0C00UL) +#define GPIOH_BASE (AHB2PERIPH_BASE + 0x1C00UL) + + +#define ADC1_BASE (AHB2PERIPH_BASE + 0x08040000UL) +#define ADC2_BASE (AHB2PERIPH_BASE + 0x08040100UL) +#define ADC12_COMMON_BASE (AHB2PERIPH_BASE + 0x08040300UL) + + +#define AES_BASE (AHB2PERIPH_BASE + 0x08060000UL) +#define RNG_BASE (AHB2PERIPH_BASE + 0x08060800UL) + + + +/* Debug MCU registers base address */ +#define DBGMCU_BASE (0xE0042000UL) + + +#define PACKAGE_BASE (0x1FFF7500UL) /*!< Package data register base address */ +#define UID_BASE (0x1FFF7590UL) /*!< Unique device ID register base address */ +#define FLASHSIZE_BASE (0x1FFF75E0UL) /*!< Flash size data register base address */ +/** + * @} + */ + +/** @addtogroup Peripheral_declaration + * @{ + */ +#define TIM2 ((TIM_TypeDef *) TIM2_BASE) +#define TIM6 ((TIM_TypeDef *) TIM6_BASE) +#define RTC ((RTC_TypeDef *) RTC_BASE) +#define WWDG ((WWDG_TypeDef *) WWDG_BASE) +#define IWDG ((IWDG_TypeDef *) IWDG_BASE) +#define TAMP ((TAMP_TypeDef *) TAMP_BASE) +#define SPI2 ((SPI_TypeDef *) SPI2_BASE) +#define USART2 ((USART_TypeDef *) USART2_BASE) +#define USART3 ((USART_TypeDef *) USART3_BASE) +#define I2C1 ((I2C_TypeDef *) I2C1_BASE) +#define I2C2 ((I2C_TypeDef *) I2C2_BASE) +#define I2C3 ((I2C_TypeDef *) I2C3_BASE) +#define CRS ((CRS_TypeDef *) CRS_BASE) +#define USB ((USB_TypeDef *) USB_BASE) +#define PWR ((PWR_TypeDef *) PWR_BASE) +#define OPAMP ((OPAMP_TypeDef *) OPAMP_BASE) +#define OPAMP1 ((OPAMP_TypeDef *) OPAMP1_BASE) +#define OPAMP1_COMMON ((OPAMP_Common_TypeDef *) OPAMP1_BASE) +#define LPTIM1 ((LPTIM_TypeDef *) LPTIM1_BASE) +#define LPUART1 ((USART_TypeDef *) LPUART1_BASE) +#define LPTIM2 ((LPTIM_TypeDef *) LPTIM2_BASE) + +#define SYSCFG ((SYSCFG_TypeDef *) SYSCFG_BASE) +#define COMP1 ((COMP_TypeDef *) COMP1_BASE) +#define EXTI ((EXTI_TypeDef *) EXTI_BASE) +#define FIREWALL ((FIREWALL_TypeDef *) FIREWALL_BASE) +#define TIM1 ((TIM_TypeDef *) TIM1_BASE) +#define SPI1 ((SPI_TypeDef *) SPI1_BASE) +#define USART1 ((USART_TypeDef *) USART1_BASE) +#define TIM15 ((TIM_TypeDef *) TIM15_BASE) +#define TIM16 ((TIM_TypeDef *) TIM16_BASE) +#define DMA1 ((DMA_TypeDef *) DMA1_BASE) +#define DMA2 ((DMA_TypeDef *) DMA2_BASE) +#define RCC ((RCC_TypeDef *) RCC_BASE) +#define FLASH ((FLASH_TypeDef *) FLASH_R_BASE) +#define CRC ((CRC_TypeDef *) CRC_BASE) +#define TSC ((TSC_TypeDef *) TSC_BASE) + +#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE) +#define GPIOB ((GPIO_TypeDef *) GPIOB_BASE) +#define GPIOC ((GPIO_TypeDef *) GPIOC_BASE) +#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE) +#define GPIOH ((GPIO_TypeDef *) GPIOH_BASE) +#define ADC1 ((ADC_TypeDef *) ADC1_BASE) +#define ADC2 ((ADC_TypeDef *) ADC2_BASE) +#define ADC12_COMMON ((ADC_Common_TypeDef *) ADC12_COMMON_BASE) +#define AES ((AES_TypeDef *) AES_BASE) +#define RNG ((RNG_TypeDef *) RNG_BASE) + + +#define DMA1_Channel1 ((DMA_Channel_TypeDef *) DMA1_Channel1_BASE) +#define DMA1_Channel2 ((DMA_Channel_TypeDef *) DMA1_Channel2_BASE) +#define DMA1_Channel3 ((DMA_Channel_TypeDef *) DMA1_Channel3_BASE) +#define DMA1_Channel4 ((DMA_Channel_TypeDef *) DMA1_Channel4_BASE) +#define DMA1_Channel5 ((DMA_Channel_TypeDef *) DMA1_Channel5_BASE) +#define DMA1_Channel6 ((DMA_Channel_TypeDef *) DMA1_Channel6_BASE) +#define DMA1_Channel7 ((DMA_Channel_TypeDef *) DMA1_Channel7_BASE) +#define DMA1_CSELR ((DMA_Request_TypeDef *) DMA1_CSELR_BASE) + + +#define DMA2_Channel1 ((DMA_Channel_TypeDef *) DMA2_Channel1_BASE) +#define DMA2_Channel2 ((DMA_Channel_TypeDef *) DMA2_Channel2_BASE) +#define DMA2_Channel3 ((DMA_Channel_TypeDef *) DMA2_Channel3_BASE) +#define DMA2_Channel4 ((DMA_Channel_TypeDef *) DMA2_Channel4_BASE) +#define DMA2_Channel5 ((DMA_Channel_TypeDef *) DMA2_Channel5_BASE) +#define DMA2_Channel6 ((DMA_Channel_TypeDef *) DMA2_Channel6_BASE) +#define DMA2_Channel7 ((DMA_Channel_TypeDef *) DMA2_Channel7_BASE) +#define DMA2_CSELR ((DMA_Request_TypeDef *) DMA2_CSELR_BASE) + + + +#define QUADSPI ((QUADSPI_TypeDef *) QSPI_R_BASE) + +#define DBGMCU ((DBGMCU_TypeDef *) DBGMCU_BASE) + +/** + * @} + */ + +/** @addtogroup Exported_constants + * @{ + */ + +/** @addtogroup Hardware_Constant_Definition + * @{ + */ +#define LSI_STARTUP_TIME 130U /*!< LSI Maximum startup time in us */ + +/** + * @} + */ + +/** @addtogroup Peripheral_Registers_Bits_Definition + * @{ + */ + +/******************************************************************************/ +/* Peripheral Registers_Bits_Definition */ +/******************************************************************************/ + +/******************************************************************************/ +/* */ +/* Analog to Digital Converter */ +/* */ +/******************************************************************************/ + +/* + * @brief Specific device feature definitions (not present on all devices in the STM32L4 series) + */ +#define ADC_MULTIMODE_SUPPORT /*!< ADC feature available only on specific devices: multimode available on devices with several ADC instances */ + +/******************** Bit definition for ADC_ISR register *******************/ +#define ADC_ISR_ADRDY_Pos (0U) +#define ADC_ISR_ADRDY_Msk (0x1UL << ADC_ISR_ADRDY_Pos) /*!< 0x00000001 */ +#define ADC_ISR_ADRDY ADC_ISR_ADRDY_Msk /*!< ADC ready flag */ +#define ADC_ISR_EOSMP_Pos (1U) +#define ADC_ISR_EOSMP_Msk (0x1UL << ADC_ISR_EOSMP_Pos) /*!< 0x00000002 */ +#define ADC_ISR_EOSMP ADC_ISR_EOSMP_Msk /*!< ADC group regular end of sampling flag */ +#define ADC_ISR_EOC_Pos (2U) +#define ADC_ISR_EOC_Msk (0x1UL << ADC_ISR_EOC_Pos) /*!< 0x00000004 */ +#define ADC_ISR_EOC ADC_ISR_EOC_Msk /*!< ADC group regular end of unitary conversion flag */ +#define ADC_ISR_EOS_Pos (3U) +#define ADC_ISR_EOS_Msk (0x1UL << ADC_ISR_EOS_Pos) /*!< 0x00000008 */ +#define ADC_ISR_EOS ADC_ISR_EOS_Msk /*!< ADC group regular end of sequence conversions flag */ +#define ADC_ISR_OVR_Pos (4U) +#define ADC_ISR_OVR_Msk (0x1UL << ADC_ISR_OVR_Pos) /*!< 0x00000010 */ +#define ADC_ISR_OVR ADC_ISR_OVR_Msk /*!< ADC group regular overrun flag */ +#define ADC_ISR_JEOC_Pos (5U) +#define ADC_ISR_JEOC_Msk (0x1UL << ADC_ISR_JEOC_Pos) /*!< 0x00000020 */ +#define ADC_ISR_JEOC ADC_ISR_JEOC_Msk /*!< ADC group injected end of unitary conversion flag */ +#define ADC_ISR_JEOS_Pos (6U) +#define ADC_ISR_JEOS_Msk (0x1UL << ADC_ISR_JEOS_Pos) /*!< 0x00000040 */ +#define ADC_ISR_JEOS ADC_ISR_JEOS_Msk /*!< ADC group injected end of sequence conversions flag */ +#define ADC_ISR_AWD1_Pos (7U) +#define ADC_ISR_AWD1_Msk (0x1UL << ADC_ISR_AWD1_Pos) /*!< 0x00000080 */ +#define ADC_ISR_AWD1 ADC_ISR_AWD1_Msk /*!< ADC analog watchdog 1 flag */ +#define ADC_ISR_AWD2_Pos (8U) +#define ADC_ISR_AWD2_Msk (0x1UL << ADC_ISR_AWD2_Pos) /*!< 0x00000100 */ +#define ADC_ISR_AWD2 ADC_ISR_AWD2_Msk /*!< ADC analog watchdog 2 flag */ +#define ADC_ISR_AWD3_Pos (9U) +#define ADC_ISR_AWD3_Msk (0x1UL << ADC_ISR_AWD3_Pos) /*!< 0x00000200 */ +#define ADC_ISR_AWD3 ADC_ISR_AWD3_Msk /*!< ADC analog watchdog 3 flag */ +#define ADC_ISR_JQOVF_Pos (10U) +#define ADC_ISR_JQOVF_Msk (0x1UL << ADC_ISR_JQOVF_Pos) /*!< 0x00000400 */ +#define ADC_ISR_JQOVF ADC_ISR_JQOVF_Msk /*!< ADC group injected contexts queue overflow flag */ + +/******************** Bit definition for ADC_IER register *******************/ +#define ADC_IER_ADRDYIE_Pos (0U) +#define ADC_IER_ADRDYIE_Msk (0x1UL << ADC_IER_ADRDYIE_Pos) /*!< 0x00000001 */ +#define ADC_IER_ADRDYIE ADC_IER_ADRDYIE_Msk /*!< ADC ready interrupt */ +#define ADC_IER_EOSMPIE_Pos (1U) +#define ADC_IER_EOSMPIE_Msk (0x1UL << ADC_IER_EOSMPIE_Pos) /*!< 0x00000002 */ +#define ADC_IER_EOSMPIE ADC_IER_EOSMPIE_Msk /*!< ADC group regular end of sampling interrupt */ +#define ADC_IER_EOCIE_Pos (2U) +#define ADC_IER_EOCIE_Msk (0x1UL << ADC_IER_EOCIE_Pos) /*!< 0x00000004 */ +#define ADC_IER_EOCIE ADC_IER_EOCIE_Msk /*!< ADC group regular end of unitary conversion interrupt */ +#define ADC_IER_EOSIE_Pos (3U) +#define ADC_IER_EOSIE_Msk (0x1UL << ADC_IER_EOSIE_Pos) /*!< 0x00000008 */ +#define ADC_IER_EOSIE ADC_IER_EOSIE_Msk /*!< ADC group regular end of sequence conversions interrupt */ +#define ADC_IER_OVRIE_Pos (4U) +#define ADC_IER_OVRIE_Msk (0x1UL << ADC_IER_OVRIE_Pos) /*!< 0x00000010 */ +#define ADC_IER_OVRIE ADC_IER_OVRIE_Msk /*!< ADC group regular overrun interrupt */ +#define ADC_IER_JEOCIE_Pos (5U) +#define ADC_IER_JEOCIE_Msk (0x1UL << ADC_IER_JEOCIE_Pos) /*!< 0x00000020 */ +#define ADC_IER_JEOCIE ADC_IER_JEOCIE_Msk /*!< ADC group injected end of unitary conversion interrupt */ +#define ADC_IER_JEOSIE_Pos (6U) +#define ADC_IER_JEOSIE_Msk (0x1UL << ADC_IER_JEOSIE_Pos) /*!< 0x00000040 */ +#define ADC_IER_JEOSIE ADC_IER_JEOSIE_Msk /*!< ADC group injected end of sequence conversions interrupt */ +#define ADC_IER_AWD1IE_Pos (7U) +#define ADC_IER_AWD1IE_Msk (0x1UL << ADC_IER_AWD1IE_Pos) /*!< 0x00000080 */ +#define ADC_IER_AWD1IE ADC_IER_AWD1IE_Msk /*!< ADC analog watchdog 1 interrupt */ +#define ADC_IER_AWD2IE_Pos (8U) +#define ADC_IER_AWD2IE_Msk (0x1UL << ADC_IER_AWD2IE_Pos) /*!< 0x00000100 */ +#define ADC_IER_AWD2IE ADC_IER_AWD2IE_Msk /*!< ADC analog watchdog 2 interrupt */ +#define ADC_IER_AWD3IE_Pos (9U) +#define ADC_IER_AWD3IE_Msk (0x1UL << ADC_IER_AWD3IE_Pos) /*!< 0x00000200 */ +#define ADC_IER_AWD3IE ADC_IER_AWD3IE_Msk /*!< ADC analog watchdog 3 interrupt */ +#define ADC_IER_JQOVFIE_Pos (10U) +#define ADC_IER_JQOVFIE_Msk (0x1UL << ADC_IER_JQOVFIE_Pos) /*!< 0x00000400 */ +#define ADC_IER_JQOVFIE ADC_IER_JQOVFIE_Msk /*!< ADC group injected contexts queue overflow interrupt */ + +/* Legacy defines */ +#define ADC_IER_ADRDY (ADC_IER_ADRDYIE) +#define ADC_IER_EOSMP (ADC_IER_EOSMPIE) +#define ADC_IER_EOC (ADC_IER_EOCIE) +#define ADC_IER_EOS (ADC_IER_EOSIE) +#define ADC_IER_OVR (ADC_IER_OVRIE) +#define ADC_IER_JEOC (ADC_IER_JEOCIE) +#define ADC_IER_JEOS (ADC_IER_JEOSIE) +#define ADC_IER_AWD1 (ADC_IER_AWD1IE) +#define ADC_IER_AWD2 (ADC_IER_AWD2IE) +#define ADC_IER_AWD3 (ADC_IER_AWD3IE) +#define ADC_IER_JQOVF (ADC_IER_JQOVFIE) + +/******************** Bit definition for ADC_CR register ********************/ +#define ADC_CR_ADEN_Pos (0U) +#define ADC_CR_ADEN_Msk (0x1UL << ADC_CR_ADEN_Pos) /*!< 0x00000001 */ +#define ADC_CR_ADEN ADC_CR_ADEN_Msk /*!< ADC enable */ +#define ADC_CR_ADDIS_Pos (1U) +#define ADC_CR_ADDIS_Msk (0x1UL << ADC_CR_ADDIS_Pos) /*!< 0x00000002 */ +#define ADC_CR_ADDIS ADC_CR_ADDIS_Msk /*!< ADC disable */ +#define ADC_CR_ADSTART_Pos (2U) +#define ADC_CR_ADSTART_Msk (0x1UL << ADC_CR_ADSTART_Pos) /*!< 0x00000004 */ +#define ADC_CR_ADSTART ADC_CR_ADSTART_Msk /*!< ADC group regular conversion start */ +#define ADC_CR_JADSTART_Pos (3U) +#define ADC_CR_JADSTART_Msk (0x1UL << ADC_CR_JADSTART_Pos) /*!< 0x00000008 */ +#define ADC_CR_JADSTART ADC_CR_JADSTART_Msk /*!< ADC group injected conversion start */ +#define ADC_CR_ADSTP_Pos (4U) +#define ADC_CR_ADSTP_Msk (0x1UL << ADC_CR_ADSTP_Pos) /*!< 0x00000010 */ +#define ADC_CR_ADSTP ADC_CR_ADSTP_Msk /*!< ADC group regular conversion stop */ +#define ADC_CR_JADSTP_Pos (5U) +#define ADC_CR_JADSTP_Msk (0x1UL << ADC_CR_JADSTP_Pos) /*!< 0x00000020 */ +#define ADC_CR_JADSTP ADC_CR_JADSTP_Msk /*!< ADC group injected conversion stop */ +#define ADC_CR_ADVREGEN_Pos (28U) +#define ADC_CR_ADVREGEN_Msk (0x1UL << ADC_CR_ADVREGEN_Pos) /*!< 0x10000000 */ +#define ADC_CR_ADVREGEN ADC_CR_ADVREGEN_Msk /*!< ADC voltage regulator enable */ +#define ADC_CR_DEEPPWD_Pos (29U) +#define ADC_CR_DEEPPWD_Msk (0x1UL << ADC_CR_DEEPPWD_Pos) /*!< 0x20000000 */ +#define ADC_CR_DEEPPWD ADC_CR_DEEPPWD_Msk /*!< ADC deep power down enable */ +#define ADC_CR_ADCALDIF_Pos (30U) +#define ADC_CR_ADCALDIF_Msk (0x1UL << ADC_CR_ADCALDIF_Pos) /*!< 0x40000000 */ +#define ADC_CR_ADCALDIF ADC_CR_ADCALDIF_Msk /*!< ADC differential mode for calibration */ +#define ADC_CR_ADCAL_Pos (31U) +#define ADC_CR_ADCAL_Msk (0x1UL << ADC_CR_ADCAL_Pos) /*!< 0x80000000 */ +#define ADC_CR_ADCAL ADC_CR_ADCAL_Msk /*!< ADC calibration */ + +/******************** Bit definition for ADC_CFGR register ******************/ +#define ADC_CFGR_DMAEN_Pos (0U) +#define ADC_CFGR_DMAEN_Msk (0x1UL << ADC_CFGR_DMAEN_Pos) /*!< 0x00000001 */ +#define ADC_CFGR_DMAEN ADC_CFGR_DMAEN_Msk /*!< ADC DMA transfer enable */ +#define ADC_CFGR_DMACFG_Pos (1U) +#define ADC_CFGR_DMACFG_Msk (0x1UL << ADC_CFGR_DMACFG_Pos) /*!< 0x00000002 */ +#define ADC_CFGR_DMACFG ADC_CFGR_DMACFG_Msk /*!< ADC DMA transfer configuration */ + +#define ADC_CFGR_RES_Pos (3U) +#define ADC_CFGR_RES_Msk (0x3UL << ADC_CFGR_RES_Pos) /*!< 0x00000018 */ +#define ADC_CFGR_RES ADC_CFGR_RES_Msk /*!< ADC data resolution */ +#define ADC_CFGR_RES_0 (0x1UL << ADC_CFGR_RES_Pos) /*!< 0x00000008 */ +#define ADC_CFGR_RES_1 (0x2UL << ADC_CFGR_RES_Pos) /*!< 0x00000010 */ + +#define ADC_CFGR_ALIGN_Pos (5U) +#define ADC_CFGR_ALIGN_Msk (0x1UL << ADC_CFGR_ALIGN_Pos) /*!< 0x00000020 */ +#define ADC_CFGR_ALIGN ADC_CFGR_ALIGN_Msk /*!< ADC data alignment */ + +#define ADC_CFGR_EXTSEL_Pos (6U) +#define ADC_CFGR_EXTSEL_Msk (0xFUL << ADC_CFGR_EXTSEL_Pos) /*!< 0x000003C0 */ +#define ADC_CFGR_EXTSEL ADC_CFGR_EXTSEL_Msk /*!< ADC group regular external trigger source */ +#define ADC_CFGR_EXTSEL_0 (0x1UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000040 */ +#define ADC_CFGR_EXTSEL_1 (0x2UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000080 */ +#define ADC_CFGR_EXTSEL_2 (0x4UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000100 */ +#define ADC_CFGR_EXTSEL_3 (0x8UL << ADC_CFGR_EXTSEL_Pos) /*!< 0x00000200 */ + +#define ADC_CFGR_EXTEN_Pos (10U) +#define ADC_CFGR_EXTEN_Msk (0x3UL << ADC_CFGR_EXTEN_Pos) /*!< 0x00000C00 */ +#define ADC_CFGR_EXTEN ADC_CFGR_EXTEN_Msk /*!< ADC group regular external trigger polarity */ +#define ADC_CFGR_EXTEN_0 (0x1UL << ADC_CFGR_EXTEN_Pos) /*!< 0x00000400 */ +#define ADC_CFGR_EXTEN_1 (0x2UL << ADC_CFGR_EXTEN_Pos) /*!< 0x00000800 */ + +#define ADC_CFGR_OVRMOD_Pos (12U) +#define ADC_CFGR_OVRMOD_Msk (0x1UL << ADC_CFGR_OVRMOD_Pos) /*!< 0x00001000 */ +#define ADC_CFGR_OVRMOD ADC_CFGR_OVRMOD_Msk /*!< ADC group regular overrun configuration */ +#define ADC_CFGR_CONT_Pos (13U) +#define ADC_CFGR_CONT_Msk (0x1UL << ADC_CFGR_CONT_Pos) /*!< 0x00002000 */ +#define ADC_CFGR_CONT ADC_CFGR_CONT_Msk /*!< ADC group regular continuous conversion mode */ +#define ADC_CFGR_AUTDLY_Pos (14U) +#define ADC_CFGR_AUTDLY_Msk (0x1UL << ADC_CFGR_AUTDLY_Pos) /*!< 0x00004000 */ +#define ADC_CFGR_AUTDLY ADC_CFGR_AUTDLY_Msk /*!< ADC low power auto wait */ + +#define ADC_CFGR_DISCEN_Pos (16U) +#define ADC_CFGR_DISCEN_Msk (0x1UL << ADC_CFGR_DISCEN_Pos) /*!< 0x00010000 */ +#define ADC_CFGR_DISCEN ADC_CFGR_DISCEN_Msk /*!< ADC group regular sequencer discontinuous mode */ + +#define ADC_CFGR_DISCNUM_Pos (17U) +#define ADC_CFGR_DISCNUM_Msk (0x7UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x000E0000 */ +#define ADC_CFGR_DISCNUM ADC_CFGR_DISCNUM_Msk /*!< ADC group regular sequencer discontinuous number of ranks */ +#define ADC_CFGR_DISCNUM_0 (0x1UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x00020000 */ +#define ADC_CFGR_DISCNUM_1 (0x2UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x00040000 */ +#define ADC_CFGR_DISCNUM_2 (0x4UL << ADC_CFGR_DISCNUM_Pos) /*!< 0x00080000 */ + +#define ADC_CFGR_JDISCEN_Pos (20U) +#define ADC_CFGR_JDISCEN_Msk (0x1UL << ADC_CFGR_JDISCEN_Pos) /*!< 0x00100000 */ +#define ADC_CFGR_JDISCEN ADC_CFGR_JDISCEN_Msk /*!< ADC group injected sequencer discontinuous mode */ +#define ADC_CFGR_JQM_Pos (21U) +#define ADC_CFGR_JQM_Msk (0x1UL << ADC_CFGR_JQM_Pos) /*!< 0x00200000 */ +#define ADC_CFGR_JQM ADC_CFGR_JQM_Msk /*!< ADC group injected contexts queue mode */ +#define ADC_CFGR_AWD1SGL_Pos (22U) +#define ADC_CFGR_AWD1SGL_Msk (0x1UL << ADC_CFGR_AWD1SGL_Pos) /*!< 0x00400000 */ +#define ADC_CFGR_AWD1SGL ADC_CFGR_AWD1SGL_Msk /*!< ADC analog watchdog 1 monitoring a single channel or all channels */ +#define ADC_CFGR_AWD1EN_Pos (23U) +#define ADC_CFGR_AWD1EN_Msk (0x1UL << ADC_CFGR_AWD1EN_Pos) /*!< 0x00800000 */ +#define ADC_CFGR_AWD1EN ADC_CFGR_AWD1EN_Msk /*!< ADC analog watchdog 1 enable on scope ADC group regular */ +#define ADC_CFGR_JAWD1EN_Pos (24U) +#define ADC_CFGR_JAWD1EN_Msk (0x1UL << ADC_CFGR_JAWD1EN_Pos) /*!< 0x01000000 */ +#define ADC_CFGR_JAWD1EN ADC_CFGR_JAWD1EN_Msk /*!< ADC analog watchdog 1 enable on scope ADC group injected */ +#define ADC_CFGR_JAUTO_Pos (25U) +#define ADC_CFGR_JAUTO_Msk (0x1UL << ADC_CFGR_JAUTO_Pos) /*!< 0x02000000 */ +#define ADC_CFGR_JAUTO ADC_CFGR_JAUTO_Msk /*!< ADC group injected automatic trigger mode */ + +#define ADC_CFGR_AWD1CH_Pos (26U) +#define ADC_CFGR_AWD1CH_Msk (0x1FUL << ADC_CFGR_AWD1CH_Pos) /*!< 0x7C000000 */ +#define ADC_CFGR_AWD1CH ADC_CFGR_AWD1CH_Msk /*!< ADC analog watchdog 1 monitored channel selection */ +#define ADC_CFGR_AWD1CH_0 (0x01UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x04000000 */ +#define ADC_CFGR_AWD1CH_1 (0x02UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x08000000 */ +#define ADC_CFGR_AWD1CH_2 (0x04UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x10000000 */ +#define ADC_CFGR_AWD1CH_3 (0x08UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x20000000 */ +#define ADC_CFGR_AWD1CH_4 (0x10UL << ADC_CFGR_AWD1CH_Pos) /*!< 0x40000000 */ + +#define ADC_CFGR_JQDIS_Pos (31U) +#define ADC_CFGR_JQDIS_Msk (0x1UL << ADC_CFGR_JQDIS_Pos) /*!< 0x80000000 */ +#define ADC_CFGR_JQDIS ADC_CFGR_JQDIS_Msk /*!< ADC group injected contexts queue disable */ + +/******************** Bit definition for ADC_CFGR2 register *****************/ +#define ADC_CFGR2_ROVSE_Pos (0U) +#define ADC_CFGR2_ROVSE_Msk (0x1UL << ADC_CFGR2_ROVSE_Pos) /*!< 0x00000001 */ +#define ADC_CFGR2_ROVSE ADC_CFGR2_ROVSE_Msk /*!< ADC oversampler enable on scope ADC group regular */ +#define ADC_CFGR2_JOVSE_Pos (1U) +#define ADC_CFGR2_JOVSE_Msk (0x1UL << ADC_CFGR2_JOVSE_Pos) /*!< 0x00000002 */ +#define ADC_CFGR2_JOVSE ADC_CFGR2_JOVSE_Msk /*!< ADC oversampler enable on scope ADC group injected */ + +#define ADC_CFGR2_OVSR_Pos (2U) +#define ADC_CFGR2_OVSR_Msk (0x7UL << ADC_CFGR2_OVSR_Pos) /*!< 0x0000001C */ +#define ADC_CFGR2_OVSR ADC_CFGR2_OVSR_Msk /*!< ADC oversampling ratio */ +#define ADC_CFGR2_OVSR_0 (0x1UL << ADC_CFGR2_OVSR_Pos) /*!< 0x00000004 */ +#define ADC_CFGR2_OVSR_1 (0x2UL << ADC_CFGR2_OVSR_Pos) /*!< 0x00000008 */ +#define ADC_CFGR2_OVSR_2 (0x4UL << ADC_CFGR2_OVSR_Pos) /*!< 0x00000010 */ + +#define ADC_CFGR2_OVSS_Pos (5U) +#define ADC_CFGR2_OVSS_Msk (0xFUL << ADC_CFGR2_OVSS_Pos) /*!< 0x000001E0 */ +#define ADC_CFGR2_OVSS ADC_CFGR2_OVSS_Msk /*!< ADC oversampling shift */ +#define ADC_CFGR2_OVSS_0 (0x1UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000020 */ +#define ADC_CFGR2_OVSS_1 (0x2UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000040 */ +#define ADC_CFGR2_OVSS_2 (0x4UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000080 */ +#define ADC_CFGR2_OVSS_3 (0x8UL << ADC_CFGR2_OVSS_Pos) /*!< 0x00000100 */ + +#define ADC_CFGR2_TROVS_Pos (9U) +#define ADC_CFGR2_TROVS_Msk (0x1UL << ADC_CFGR2_TROVS_Pos) /*!< 0x00000200 */ +#define ADC_CFGR2_TROVS ADC_CFGR2_TROVS_Msk /*!< ADC oversampling discontinuous mode (triggered mode) for ADC group regular */ +#define ADC_CFGR2_ROVSM_Pos (10U) +#define ADC_CFGR2_ROVSM_Msk (0x1UL << ADC_CFGR2_ROVSM_Pos) /*!< 0x00000400 */ +#define ADC_CFGR2_ROVSM ADC_CFGR2_ROVSM_Msk /*!< ADC oversampling mode managing interlaced conversions of ADC group regular and group injected */ + +/******************** Bit definition for ADC_SMPR1 register *****************/ +#define ADC_SMPR1_SMP0_Pos (0U) +#define ADC_SMPR1_SMP0_Msk (0x7UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000007 */ +#define ADC_SMPR1_SMP0 ADC_SMPR1_SMP0_Msk /*!< ADC channel 0 sampling time selection */ +#define ADC_SMPR1_SMP0_0 (0x1UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000001 */ +#define ADC_SMPR1_SMP0_1 (0x2UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000002 */ +#define ADC_SMPR1_SMP0_2 (0x4UL << ADC_SMPR1_SMP0_Pos) /*!< 0x00000004 */ + +#define ADC_SMPR1_SMP1_Pos (3U) +#define ADC_SMPR1_SMP1_Msk (0x7UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000038 */ +#define ADC_SMPR1_SMP1 ADC_SMPR1_SMP1_Msk /*!< ADC channel 1 sampling time selection */ +#define ADC_SMPR1_SMP1_0 (0x1UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000008 */ +#define ADC_SMPR1_SMP1_1 (0x2UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000010 */ +#define ADC_SMPR1_SMP1_2 (0x4UL << ADC_SMPR1_SMP1_Pos) /*!< 0x00000020 */ + +#define ADC_SMPR1_SMP2_Pos (6U) +#define ADC_SMPR1_SMP2_Msk (0x7UL << ADC_SMPR1_SMP2_Pos) /*!< 0x000001C0 */ +#define ADC_SMPR1_SMP2 ADC_SMPR1_SMP2_Msk /*!< ADC channel 2 sampling time selection */ +#define ADC_SMPR1_SMP2_0 (0x1UL << ADC_SMPR1_SMP2_Pos) /*!< 0x00000040 */ +#define ADC_SMPR1_SMP2_1 (0x2UL << ADC_SMPR1_SMP2_Pos) /*!< 0x00000080 */ +#define ADC_SMPR1_SMP2_2 (0x4UL << ADC_SMPR1_SMP2_Pos) /*!< 0x00000100 */ + +#define ADC_SMPR1_SMP3_Pos (9U) +#define ADC_SMPR1_SMP3_Msk (0x7UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000E00 */ +#define ADC_SMPR1_SMP3 ADC_SMPR1_SMP3_Msk /*!< ADC channel 3 sampling time selection */ +#define ADC_SMPR1_SMP3_0 (0x1UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000200 */ +#define ADC_SMPR1_SMP3_1 (0x2UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000400 */ +#define ADC_SMPR1_SMP3_2 (0x4UL << ADC_SMPR1_SMP3_Pos) /*!< 0x00000800 */ + +#define ADC_SMPR1_SMP4_Pos (12U) +#define ADC_SMPR1_SMP4_Msk (0x7UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00007000 */ +#define ADC_SMPR1_SMP4 ADC_SMPR1_SMP4_Msk /*!< ADC channel 4 sampling time selection */ +#define ADC_SMPR1_SMP4_0 (0x1UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00001000 */ +#define ADC_SMPR1_SMP4_1 (0x2UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00002000 */ +#define ADC_SMPR1_SMP4_2 (0x4UL << ADC_SMPR1_SMP4_Pos) /*!< 0x00004000 */ + +#define ADC_SMPR1_SMP5_Pos (15U) +#define ADC_SMPR1_SMP5_Msk (0x7UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00038000 */ +#define ADC_SMPR1_SMP5 ADC_SMPR1_SMP5_Msk /*!< ADC channel 5 sampling time selection */ +#define ADC_SMPR1_SMP5_0 (0x1UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00008000 */ +#define ADC_SMPR1_SMP5_1 (0x2UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00010000 */ +#define ADC_SMPR1_SMP5_2 (0x4UL << ADC_SMPR1_SMP5_Pos) /*!< 0x00020000 */ + +#define ADC_SMPR1_SMP6_Pos (18U) +#define ADC_SMPR1_SMP6_Msk (0x7UL << ADC_SMPR1_SMP6_Pos) /*!< 0x001C0000 */ +#define ADC_SMPR1_SMP6 ADC_SMPR1_SMP6_Msk /*!< ADC channel 6 sampling time selection */ +#define ADC_SMPR1_SMP6_0 (0x1UL << ADC_SMPR1_SMP6_Pos) /*!< 0x00040000 */ +#define ADC_SMPR1_SMP6_1 (0x2UL << ADC_SMPR1_SMP6_Pos) /*!< 0x00080000 */ +#define ADC_SMPR1_SMP6_2 (0x4UL << ADC_SMPR1_SMP6_Pos) /*!< 0x00100000 */ + +#define ADC_SMPR1_SMP7_Pos (21U) +#define ADC_SMPR1_SMP7_Msk (0x7UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00E00000 */ +#define ADC_SMPR1_SMP7 ADC_SMPR1_SMP7_Msk /*!< ADC channel 7 sampling time selection */ +#define ADC_SMPR1_SMP7_0 (0x1UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00200000 */ +#define ADC_SMPR1_SMP7_1 (0x2UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00400000 */ +#define ADC_SMPR1_SMP7_2 (0x4UL << ADC_SMPR1_SMP7_Pos) /*!< 0x00800000 */ + +#define ADC_SMPR1_SMP8_Pos (24U) +#define ADC_SMPR1_SMP8_Msk (0x7UL << ADC_SMPR1_SMP8_Pos) /*!< 0x07000000 */ +#define ADC_SMPR1_SMP8 ADC_SMPR1_SMP8_Msk /*!< ADC channel 8 sampling time selection */ +#define ADC_SMPR1_SMP8_0 (0x1UL << ADC_SMPR1_SMP8_Pos) /*!< 0x01000000 */ +#define ADC_SMPR1_SMP8_1 (0x2UL << ADC_SMPR1_SMP8_Pos) /*!< 0x02000000 */ +#define ADC_SMPR1_SMP8_2 (0x4UL << ADC_SMPR1_SMP8_Pos) /*!< 0x04000000 */ + +#define ADC_SMPR1_SMP9_Pos (27U) +#define ADC_SMPR1_SMP9_Msk (0x7UL << ADC_SMPR1_SMP9_Pos) /*!< 0x38000000 */ +#define ADC_SMPR1_SMP9 ADC_SMPR1_SMP9_Msk /*!< ADC channel 9 sampling time selection */ +#define ADC_SMPR1_SMP9_0 (0x1UL << ADC_SMPR1_SMP9_Pos) /*!< 0x08000000 */ +#define ADC_SMPR1_SMP9_1 (0x2UL << ADC_SMPR1_SMP9_Pos) /*!< 0x10000000 */ +#define ADC_SMPR1_SMP9_2 (0x4UL << ADC_SMPR1_SMP9_Pos) /*!< 0x20000000 */ + +#define ADC_SMPR1_SMPPLUS_Pos (31U) +#define ADC_SMPR1_SMPPLUS_Msk (0x1UL << ADC_SMPR1_SMPPLUS_Pos) /*!< 0x80000000 */ +#define ADC_SMPR1_SMPPLUS ADC_SMPR1_SMPPLUS_Msk /*!< ADC channels sampling time additional setting */ + +/******************** Bit definition for ADC_SMPR2 register *****************/ +#define ADC_SMPR2_SMP10_Pos (0U) +#define ADC_SMPR2_SMP10_Msk (0x7UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000007 */ +#define ADC_SMPR2_SMP10 ADC_SMPR2_SMP10_Msk /*!< ADC channel 10 sampling time selection */ +#define ADC_SMPR2_SMP10_0 (0x1UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000001 */ +#define ADC_SMPR2_SMP10_1 (0x2UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000002 */ +#define ADC_SMPR2_SMP10_2 (0x4UL << ADC_SMPR2_SMP10_Pos) /*!< 0x00000004 */ + +#define ADC_SMPR2_SMP11_Pos (3U) +#define ADC_SMPR2_SMP11_Msk (0x7UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000038 */ +#define ADC_SMPR2_SMP11 ADC_SMPR2_SMP11_Msk /*!< ADC channel 11 sampling time selection */ +#define ADC_SMPR2_SMP11_0 (0x1UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000008 */ +#define ADC_SMPR2_SMP11_1 (0x2UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000010 */ +#define ADC_SMPR2_SMP11_2 (0x4UL << ADC_SMPR2_SMP11_Pos) /*!< 0x00000020 */ + +#define ADC_SMPR2_SMP12_Pos (6U) +#define ADC_SMPR2_SMP12_Msk (0x7UL << ADC_SMPR2_SMP12_Pos) /*!< 0x000001C0 */ +#define ADC_SMPR2_SMP12 ADC_SMPR2_SMP12_Msk /*!< ADC channel 12 sampling time selection */ +#define ADC_SMPR2_SMP12_0 (0x1UL << ADC_SMPR2_SMP12_Pos) /*!< 0x00000040 */ +#define ADC_SMPR2_SMP12_1 (0x2UL << ADC_SMPR2_SMP12_Pos) /*!< 0x00000080 */ +#define ADC_SMPR2_SMP12_2 (0x4UL << ADC_SMPR2_SMP12_Pos) /*!< 0x00000100 */ + +#define ADC_SMPR2_SMP13_Pos (9U) +#define ADC_SMPR2_SMP13_Msk (0x7UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000E00 */ +#define ADC_SMPR2_SMP13 ADC_SMPR2_SMP13_Msk /*!< ADC channel 13 sampling time selection */ +#define ADC_SMPR2_SMP13_0 (0x1UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000200 */ +#define ADC_SMPR2_SMP13_1 (0x2UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000400 */ +#define ADC_SMPR2_SMP13_2 (0x4UL << ADC_SMPR2_SMP13_Pos) /*!< 0x00000800 */ + +#define ADC_SMPR2_SMP14_Pos (12U) +#define ADC_SMPR2_SMP14_Msk (0x7UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00007000 */ +#define ADC_SMPR2_SMP14 ADC_SMPR2_SMP14_Msk /*!< ADC channel 14 sampling time selection */ +#define ADC_SMPR2_SMP14_0 (0x1UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00001000 */ +#define ADC_SMPR2_SMP14_1 (0x2UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00002000 */ +#define ADC_SMPR2_SMP14_2 (0x4UL << ADC_SMPR2_SMP14_Pos) /*!< 0x00004000 */ + +#define ADC_SMPR2_SMP15_Pos (15U) +#define ADC_SMPR2_SMP15_Msk (0x7UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00038000 */ +#define ADC_SMPR2_SMP15 ADC_SMPR2_SMP15_Msk /*!< ADC channel 15 sampling time selection */ +#define ADC_SMPR2_SMP15_0 (0x1UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00008000 */ +#define ADC_SMPR2_SMP15_1 (0x2UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00010000 */ +#define ADC_SMPR2_SMP15_2 (0x4UL << ADC_SMPR2_SMP15_Pos) /*!< 0x00020000 */ + +#define ADC_SMPR2_SMP16_Pos (18U) +#define ADC_SMPR2_SMP16_Msk (0x7UL << ADC_SMPR2_SMP16_Pos) /*!< 0x001C0000 */ +#define ADC_SMPR2_SMP16 ADC_SMPR2_SMP16_Msk /*!< ADC channel 16 sampling time selection */ +#define ADC_SMPR2_SMP16_0 (0x1UL << ADC_SMPR2_SMP16_Pos) /*!< 0x00040000 */ +#define ADC_SMPR2_SMP16_1 (0x2UL << ADC_SMPR2_SMP16_Pos) /*!< 0x00080000 */ +#define ADC_SMPR2_SMP16_2 (0x4UL << ADC_SMPR2_SMP16_Pos) /*!< 0x00100000 */ + +#define ADC_SMPR2_SMP17_Pos (21U) +#define ADC_SMPR2_SMP17_Msk (0x7UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00E00000 */ +#define ADC_SMPR2_SMP17 ADC_SMPR2_SMP17_Msk /*!< ADC channel 17 sampling time selection */ +#define ADC_SMPR2_SMP17_0 (0x1UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00200000 */ +#define ADC_SMPR2_SMP17_1 (0x2UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00400000 */ +#define ADC_SMPR2_SMP17_2 (0x4UL << ADC_SMPR2_SMP17_Pos) /*!< 0x00800000 */ + +#define ADC_SMPR2_SMP18_Pos (24U) +#define ADC_SMPR2_SMP18_Msk (0x7UL << ADC_SMPR2_SMP18_Pos) /*!< 0x07000000 */ +#define ADC_SMPR2_SMP18 ADC_SMPR2_SMP18_Msk /*!< ADC channel 18 sampling time selection */ +#define ADC_SMPR2_SMP18_0 (0x1UL << ADC_SMPR2_SMP18_Pos) /*!< 0x01000000 */ +#define ADC_SMPR2_SMP18_1 (0x2UL << ADC_SMPR2_SMP18_Pos) /*!< 0x02000000 */ +#define ADC_SMPR2_SMP18_2 (0x4UL << ADC_SMPR2_SMP18_Pos) /*!< 0x04000000 */ + +/******************** Bit definition for ADC_TR1 register *******************/ +#define ADC_TR1_LT1_Pos (0U) +#define ADC_TR1_LT1_Msk (0xFFFUL << ADC_TR1_LT1_Pos) /*!< 0x00000FFF */ +#define ADC_TR1_LT1 ADC_TR1_LT1_Msk /*!< ADC analog watchdog 1 threshold low */ +#define ADC_TR1_LT1_0 (0x001UL << ADC_TR1_LT1_Pos) /*!< 0x00000001 */ +#define ADC_TR1_LT1_1 (0x002UL << ADC_TR1_LT1_Pos) /*!< 0x00000002 */ +#define ADC_TR1_LT1_2 (0x004UL << ADC_TR1_LT1_Pos) /*!< 0x00000004 */ +#define ADC_TR1_LT1_3 (0x008UL << ADC_TR1_LT1_Pos) /*!< 0x00000008 */ +#define ADC_TR1_LT1_4 (0x010UL << ADC_TR1_LT1_Pos) /*!< 0x00000010 */ +#define ADC_TR1_LT1_5 (0x020UL << ADC_TR1_LT1_Pos) /*!< 0x00000020 */ +#define ADC_TR1_LT1_6 (0x040UL << ADC_TR1_LT1_Pos) /*!< 0x00000040 */ +#define ADC_TR1_LT1_7 (0x080UL << ADC_TR1_LT1_Pos) /*!< 0x00000080 */ +#define ADC_TR1_LT1_8 (0x100UL << ADC_TR1_LT1_Pos) /*!< 0x00000100 */ +#define ADC_TR1_LT1_9 (0x200UL << ADC_TR1_LT1_Pos) /*!< 0x00000200 */ +#define ADC_TR1_LT1_10 (0x400UL << ADC_TR1_LT1_Pos) /*!< 0x00000400 */ +#define ADC_TR1_LT1_11 (0x800UL << ADC_TR1_LT1_Pos) /*!< 0x00000800 */ + +#define ADC_TR1_HT1_Pos (16U) +#define ADC_TR1_HT1_Msk (0xFFFUL << ADC_TR1_HT1_Pos) /*!< 0x0FFF0000 */ +#define ADC_TR1_HT1 ADC_TR1_HT1_Msk /*!< ADC Analog watchdog 1 threshold high */ +#define ADC_TR1_HT1_0 (0x001UL << ADC_TR1_HT1_Pos) /*!< 0x00010000 */ +#define ADC_TR1_HT1_1 (0x002UL << ADC_TR1_HT1_Pos) /*!< 0x00020000 */ +#define ADC_TR1_HT1_2 (0x004UL << ADC_TR1_HT1_Pos) /*!< 0x00040000 */ +#define ADC_TR1_HT1_3 (0x008UL << ADC_TR1_HT1_Pos) /*!< 0x00080000 */ +#define ADC_TR1_HT1_4 (0x010UL << ADC_TR1_HT1_Pos) /*!< 0x00100000 */ +#define ADC_TR1_HT1_5 (0x020UL << ADC_TR1_HT1_Pos) /*!< 0x00200000 */ +#define ADC_TR1_HT1_6 (0x040UL << ADC_TR1_HT1_Pos) /*!< 0x00400000 */ +#define ADC_TR1_HT1_7 (0x080UL << ADC_TR1_HT1_Pos) /*!< 0x00800000 */ +#define ADC_TR1_HT1_8 (0x100UL << ADC_TR1_HT1_Pos) /*!< 0x01000000 */ +#define ADC_TR1_HT1_9 (0x200UL << ADC_TR1_HT1_Pos) /*!< 0x02000000 */ +#define ADC_TR1_HT1_10 (0x400UL << ADC_TR1_HT1_Pos) /*!< 0x04000000 */ +#define ADC_TR1_HT1_11 (0x800UL << ADC_TR1_HT1_Pos) /*!< 0x08000000 */ + +/******************** Bit definition for ADC_TR2 register *******************/ +#define ADC_TR2_LT2_Pos (0U) +#define ADC_TR2_LT2_Msk (0xFFUL << ADC_TR2_LT2_Pos) /*!< 0x000000FF */ +#define ADC_TR2_LT2 ADC_TR2_LT2_Msk /*!< ADC analog watchdog 2 threshold low */ +#define ADC_TR2_LT2_0 (0x01UL << ADC_TR2_LT2_Pos) /*!< 0x00000001 */ +#define ADC_TR2_LT2_1 (0x02UL << ADC_TR2_LT2_Pos) /*!< 0x00000002 */ +#define ADC_TR2_LT2_2 (0x04UL << ADC_TR2_LT2_Pos) /*!< 0x00000004 */ +#define ADC_TR2_LT2_3 (0x08UL << ADC_TR2_LT2_Pos) /*!< 0x00000008 */ +#define ADC_TR2_LT2_4 (0x10UL << ADC_TR2_LT2_Pos) /*!< 0x00000010 */ +#define ADC_TR2_LT2_5 (0x20UL << ADC_TR2_LT2_Pos) /*!< 0x00000020 */ +#define ADC_TR2_LT2_6 (0x40UL << ADC_TR2_LT2_Pos) /*!< 0x00000040 */ +#define ADC_TR2_LT2_7 (0x80UL << ADC_TR2_LT2_Pos) /*!< 0x00000080 */ + +#define ADC_TR2_HT2_Pos (16U) +#define ADC_TR2_HT2_Msk (0xFFUL << ADC_TR2_HT2_Pos) /*!< 0x00FF0000 */ +#define ADC_TR2_HT2 ADC_TR2_HT2_Msk /*!< ADC analog watchdog 2 threshold high */ +#define ADC_TR2_HT2_0 (0x01UL << ADC_TR2_HT2_Pos) /*!< 0x00010000 */ +#define ADC_TR2_HT2_1 (0x02UL << ADC_TR2_HT2_Pos) /*!< 0x00020000 */ +#define ADC_TR2_HT2_2 (0x04UL << ADC_TR2_HT2_Pos) /*!< 0x00040000 */ +#define ADC_TR2_HT2_3 (0x08UL << ADC_TR2_HT2_Pos) /*!< 0x00080000 */ +#define ADC_TR2_HT2_4 (0x10UL << ADC_TR2_HT2_Pos) /*!< 0x00100000 */ +#define ADC_TR2_HT2_5 (0x20UL << ADC_TR2_HT2_Pos) /*!< 0x00200000 */ +#define ADC_TR2_HT2_6 (0x40UL << ADC_TR2_HT2_Pos) /*!< 0x00400000 */ +#define ADC_TR2_HT2_7 (0x80UL << ADC_TR2_HT2_Pos) /*!< 0x00800000 */ + +/******************** Bit definition for ADC_TR3 register *******************/ +#define ADC_TR3_LT3_Pos (0U) +#define ADC_TR3_LT3_Msk (0xFFUL << ADC_TR3_LT3_Pos) /*!< 0x000000FF */ +#define ADC_TR3_LT3 ADC_TR3_LT3_Msk /*!< ADC analog watchdog 3 threshold low */ +#define ADC_TR3_LT3_0 (0x01UL << ADC_TR3_LT3_Pos) /*!< 0x00000001 */ +#define ADC_TR3_LT3_1 (0x02UL << ADC_TR3_LT3_Pos) /*!< 0x00000002 */ +#define ADC_TR3_LT3_2 (0x04UL << ADC_TR3_LT3_Pos) /*!< 0x00000004 */ +#define ADC_TR3_LT3_3 (0x08UL << ADC_TR3_LT3_Pos) /*!< 0x00000008 */ +#define ADC_TR3_LT3_4 (0x10UL << ADC_TR3_LT3_Pos) /*!< 0x00000010 */ +#define ADC_TR3_LT3_5 (0x20UL << ADC_TR3_LT3_Pos) /*!< 0x00000020 */ +#define ADC_TR3_LT3_6 (0x40UL << ADC_TR3_LT3_Pos) /*!< 0x00000040 */ +#define ADC_TR3_LT3_7 (0x80UL << ADC_TR3_LT3_Pos) /*!< 0x00000080 */ + +#define ADC_TR3_HT3_Pos (16U) +#define ADC_TR3_HT3_Msk (0xFFUL << ADC_TR3_HT3_Pos) /*!< 0x00FF0000 */ +#define ADC_TR3_HT3 ADC_TR3_HT3_Msk /*!< ADC analog watchdog 3 threshold high */ +#define ADC_TR3_HT3_0 (0x01UL << ADC_TR3_HT3_Pos) /*!< 0x00010000 */ +#define ADC_TR3_HT3_1 (0x02UL << ADC_TR3_HT3_Pos) /*!< 0x00020000 */ +#define ADC_TR3_HT3_2 (0x04UL << ADC_TR3_HT3_Pos) /*!< 0x00040000 */ +#define ADC_TR3_HT3_3 (0x08UL << ADC_TR3_HT3_Pos) /*!< 0x00080000 */ +#define ADC_TR3_HT3_4 (0x10UL << ADC_TR3_HT3_Pos) /*!< 0x00100000 */ +#define ADC_TR3_HT3_5 (0x20UL << ADC_TR3_HT3_Pos) /*!< 0x00200000 */ +#define ADC_TR3_HT3_6 (0x40UL << ADC_TR3_HT3_Pos) /*!< 0x00400000 */ +#define ADC_TR3_HT3_7 (0x80UL << ADC_TR3_HT3_Pos) /*!< 0x00800000 */ + +/******************** Bit definition for ADC_SQR1 register ******************/ +#define ADC_SQR1_L_Pos (0U) +#define ADC_SQR1_L_Msk (0xFUL << ADC_SQR1_L_Pos) /*!< 0x0000000F */ +#define ADC_SQR1_L ADC_SQR1_L_Msk /*!< ADC group regular sequencer scan length */ +#define ADC_SQR1_L_0 (0x1UL << ADC_SQR1_L_Pos) /*!< 0x00000001 */ +#define ADC_SQR1_L_1 (0x2UL << ADC_SQR1_L_Pos) /*!< 0x00000002 */ +#define ADC_SQR1_L_2 (0x4UL << ADC_SQR1_L_Pos) /*!< 0x00000004 */ +#define ADC_SQR1_L_3 (0x8UL << ADC_SQR1_L_Pos) /*!< 0x00000008 */ + +#define ADC_SQR1_SQ1_Pos (6U) +#define ADC_SQR1_SQ1_Msk (0x1FUL << ADC_SQR1_SQ1_Pos) /*!< 0x000007C0 */ +#define ADC_SQR1_SQ1 ADC_SQR1_SQ1_Msk /*!< ADC group regular sequencer rank 1 */ +#define ADC_SQR1_SQ1_0 (0x01UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000040 */ +#define ADC_SQR1_SQ1_1 (0x02UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000080 */ +#define ADC_SQR1_SQ1_2 (0x04UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000100 */ +#define ADC_SQR1_SQ1_3 (0x08UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000200 */ +#define ADC_SQR1_SQ1_4 (0x10UL << ADC_SQR1_SQ1_Pos) /*!< 0x00000400 */ + +#define ADC_SQR1_SQ2_Pos (12U) +#define ADC_SQR1_SQ2_Msk (0x1FUL << ADC_SQR1_SQ2_Pos) /*!< 0x0001F000 */ +#define ADC_SQR1_SQ2 ADC_SQR1_SQ2_Msk /*!< ADC group regular sequencer rank 2 */ +#define ADC_SQR1_SQ2_0 (0x01UL << ADC_SQR1_SQ2_Pos) /*!< 0x00001000 */ +#define ADC_SQR1_SQ2_1 (0x02UL << ADC_SQR1_SQ2_Pos) /*!< 0x00002000 */ +#define ADC_SQR1_SQ2_2 (0x04UL << ADC_SQR1_SQ2_Pos) /*!< 0x00004000 */ +#define ADC_SQR1_SQ2_3 (0x08UL << ADC_SQR1_SQ2_Pos) /*!< 0x00008000 */ +#define ADC_SQR1_SQ2_4 (0x10UL << ADC_SQR1_SQ2_Pos) /*!< 0x00010000 */ + +#define ADC_SQR1_SQ3_Pos (18U) +#define ADC_SQR1_SQ3_Msk (0x1FUL << ADC_SQR1_SQ3_Pos) /*!< 0x007C0000 */ +#define ADC_SQR1_SQ3 ADC_SQR1_SQ3_Msk /*!< ADC group regular sequencer rank 3 */ +#define ADC_SQR1_SQ3_0 (0x01UL << ADC_SQR1_SQ3_Pos) /*!< 0x00040000 */ +#define ADC_SQR1_SQ3_1 (0x02UL << ADC_SQR1_SQ3_Pos) /*!< 0x00080000 */ +#define ADC_SQR1_SQ3_2 (0x04UL << ADC_SQR1_SQ3_Pos) /*!< 0x00100000 */ +#define ADC_SQR1_SQ3_3 (0x08UL << ADC_SQR1_SQ3_Pos) /*!< 0x00200000 */ +#define ADC_SQR1_SQ3_4 (0x10UL << ADC_SQR1_SQ3_Pos) /*!< 0x00400000 */ + +#define ADC_SQR1_SQ4_Pos (24U) +#define ADC_SQR1_SQ4_Msk (0x1FUL << ADC_SQR1_SQ4_Pos) /*!< 0x1F000000 */ +#define ADC_SQR1_SQ4 ADC_SQR1_SQ4_Msk /*!< ADC group regular sequencer rank 4 */ +#define ADC_SQR1_SQ4_0 (0x01UL << ADC_SQR1_SQ4_Pos) /*!< 0x01000000 */ +#define ADC_SQR1_SQ4_1 (0x02UL << ADC_SQR1_SQ4_Pos) /*!< 0x02000000 */ +#define ADC_SQR1_SQ4_2 (0x04UL << ADC_SQR1_SQ4_Pos) /*!< 0x04000000 */ +#define ADC_SQR1_SQ4_3 (0x08UL << ADC_SQR1_SQ4_Pos) /*!< 0x08000000 */ +#define ADC_SQR1_SQ4_4 (0x10UL << ADC_SQR1_SQ4_Pos) /*!< 0x10000000 */ + +/******************** Bit definition for ADC_SQR2 register ******************/ +#define ADC_SQR2_SQ5_Pos (0U) +#define ADC_SQR2_SQ5_Msk (0x1FUL << ADC_SQR2_SQ5_Pos) /*!< 0x0000001F */ +#define ADC_SQR2_SQ5 ADC_SQR2_SQ5_Msk /*!< ADC group regular sequencer rank 5 */ +#define ADC_SQR2_SQ5_0 (0x01UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000001 */ +#define ADC_SQR2_SQ5_1 (0x02UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000002 */ +#define ADC_SQR2_SQ5_2 (0x04UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000004 */ +#define ADC_SQR2_SQ5_3 (0x08UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000008 */ +#define ADC_SQR2_SQ5_4 (0x10UL << ADC_SQR2_SQ5_Pos) /*!< 0x00000010 */ + +#define ADC_SQR2_SQ6_Pos (6U) +#define ADC_SQR2_SQ6_Msk (0x1FUL << ADC_SQR2_SQ6_Pos) /*!< 0x000007C0 */ +#define ADC_SQR2_SQ6 ADC_SQR2_SQ6_Msk /*!< ADC group regular sequencer rank 6 */ +#define ADC_SQR2_SQ6_0 (0x01UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000040 */ +#define ADC_SQR2_SQ6_1 (0x02UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000080 */ +#define ADC_SQR2_SQ6_2 (0x04UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000100 */ +#define ADC_SQR2_SQ6_3 (0x08UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000200 */ +#define ADC_SQR2_SQ6_4 (0x10UL << ADC_SQR2_SQ6_Pos) /*!< 0x00000400 */ + +#define ADC_SQR2_SQ7_Pos (12U) +#define ADC_SQR2_SQ7_Msk (0x1FUL << ADC_SQR2_SQ7_Pos) /*!< 0x0001F000 */ +#define ADC_SQR2_SQ7 ADC_SQR2_SQ7_Msk /*!< ADC group regular sequencer rank 7 */ +#define ADC_SQR2_SQ7_0 (0x01UL << ADC_SQR2_SQ7_Pos) /*!< 0x00001000 */ +#define ADC_SQR2_SQ7_1 (0x02UL << ADC_SQR2_SQ7_Pos) /*!< 0x00002000 */ +#define ADC_SQR2_SQ7_2 (0x04UL << ADC_SQR2_SQ7_Pos) /*!< 0x00004000 */ +#define ADC_SQR2_SQ7_3 (0x08UL << ADC_SQR2_SQ7_Pos) /*!< 0x00008000 */ +#define ADC_SQR2_SQ7_4 (0x10UL << ADC_SQR2_SQ7_Pos) /*!< 0x00010000 */ + +#define ADC_SQR2_SQ8_Pos (18U) +#define ADC_SQR2_SQ8_Msk (0x1FUL << ADC_SQR2_SQ8_Pos) /*!< 0x007C0000 */ +#define ADC_SQR2_SQ8 ADC_SQR2_SQ8_Msk /*!< ADC group regular sequencer rank 8 */ +#define ADC_SQR2_SQ8_0 (0x01UL << ADC_SQR2_SQ8_Pos) /*!< 0x00040000 */ +#define ADC_SQR2_SQ8_1 (0x02UL << ADC_SQR2_SQ8_Pos) /*!< 0x00080000 */ +#define ADC_SQR2_SQ8_2 (0x04UL << ADC_SQR2_SQ8_Pos) /*!< 0x00100000 */ +#define ADC_SQR2_SQ8_3 (0x08UL << ADC_SQR2_SQ8_Pos) /*!< 0x00200000 */ +#define ADC_SQR2_SQ8_4 (0x10UL << ADC_SQR2_SQ8_Pos) /*!< 0x00400000 */ + +#define ADC_SQR2_SQ9_Pos (24U) +#define ADC_SQR2_SQ9_Msk (0x1FUL << ADC_SQR2_SQ9_Pos) /*!< 0x1F000000 */ +#define ADC_SQR2_SQ9 ADC_SQR2_SQ9_Msk /*!< ADC group regular sequencer rank 9 */ +#define ADC_SQR2_SQ9_0 (0x01UL << ADC_SQR2_SQ9_Pos) /*!< 0x01000000 */ +#define ADC_SQR2_SQ9_1 (0x02UL << ADC_SQR2_SQ9_Pos) /*!< 0x02000000 */ +#define ADC_SQR2_SQ9_2 (0x04UL << ADC_SQR2_SQ9_Pos) /*!< 0x04000000 */ +#define ADC_SQR2_SQ9_3 (0x08UL << ADC_SQR2_SQ9_Pos) /*!< 0x08000000 */ +#define ADC_SQR2_SQ9_4 (0x10UL << ADC_SQR2_SQ9_Pos) /*!< 0x10000000 */ + +/******************** Bit definition for ADC_SQR3 register ******************/ +#define ADC_SQR3_SQ10_Pos (0U) +#define ADC_SQR3_SQ10_Msk (0x1FUL << ADC_SQR3_SQ10_Pos) /*!< 0x0000001F */ +#define ADC_SQR3_SQ10 ADC_SQR3_SQ10_Msk /*!< ADC group regular sequencer rank 10 */ +#define ADC_SQR3_SQ10_0 (0x01UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000001 */ +#define ADC_SQR3_SQ10_1 (0x02UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000002 */ +#define ADC_SQR3_SQ10_2 (0x04UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000004 */ +#define ADC_SQR3_SQ10_3 (0x08UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000008 */ +#define ADC_SQR3_SQ10_4 (0x10UL << ADC_SQR3_SQ10_Pos) /*!< 0x00000010 */ + +#define ADC_SQR3_SQ11_Pos (6U) +#define ADC_SQR3_SQ11_Msk (0x1FUL << ADC_SQR3_SQ11_Pos) /*!< 0x000007C0 */ +#define ADC_SQR3_SQ11 ADC_SQR3_SQ11_Msk /*!< ADC group regular sequencer rank 11 */ +#define ADC_SQR3_SQ11_0 (0x01UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000040 */ +#define ADC_SQR3_SQ11_1 (0x02UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000080 */ +#define ADC_SQR3_SQ11_2 (0x04UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000100 */ +#define ADC_SQR3_SQ11_3 (0x08UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000200 */ +#define ADC_SQR3_SQ11_4 (0x10UL << ADC_SQR3_SQ11_Pos) /*!< 0x00000400 */ + +#define ADC_SQR3_SQ12_Pos (12U) +#define ADC_SQR3_SQ12_Msk (0x1FUL << ADC_SQR3_SQ12_Pos) /*!< 0x0001F000 */ +#define ADC_SQR3_SQ12 ADC_SQR3_SQ12_Msk /*!< ADC group regular sequencer rank 12 */ +#define ADC_SQR3_SQ12_0 (0x01UL << ADC_SQR3_SQ12_Pos) /*!< 0x00001000 */ +#define ADC_SQR3_SQ12_1 (0x02UL << ADC_SQR3_SQ12_Pos) /*!< 0x00002000 */ +#define ADC_SQR3_SQ12_2 (0x04UL << ADC_SQR3_SQ12_Pos) /*!< 0x00004000 */ +#define ADC_SQR3_SQ12_3 (0x08UL << ADC_SQR3_SQ12_Pos) /*!< 0x00008000 */ +#define ADC_SQR3_SQ12_4 (0x10UL << ADC_SQR3_SQ12_Pos) /*!< 0x00010000 */ + +#define ADC_SQR3_SQ13_Pos (18U) +#define ADC_SQR3_SQ13_Msk (0x1FUL << ADC_SQR3_SQ13_Pos) /*!< 0x007C0000 */ +#define ADC_SQR3_SQ13 ADC_SQR3_SQ13_Msk /*!< ADC group regular sequencer rank 13 */ +#define ADC_SQR3_SQ13_0 (0x01UL << ADC_SQR3_SQ13_Pos) /*!< 0x00040000 */ +#define ADC_SQR3_SQ13_1 (0x02UL << ADC_SQR3_SQ13_Pos) /*!< 0x00080000 */ +#define ADC_SQR3_SQ13_2 (0x04UL << ADC_SQR3_SQ13_Pos) /*!< 0x00100000 */ +#define ADC_SQR3_SQ13_3 (0x08UL << ADC_SQR3_SQ13_Pos) /*!< 0x00200000 */ +#define ADC_SQR3_SQ13_4 (0x10UL << ADC_SQR3_SQ13_Pos) /*!< 0x00400000 */ + +#define ADC_SQR3_SQ14_Pos (24U) +#define ADC_SQR3_SQ14_Msk (0x1FUL << ADC_SQR3_SQ14_Pos) /*!< 0x1F000000 */ +#define ADC_SQR3_SQ14 ADC_SQR3_SQ14_Msk /*!< ADC group regular sequencer rank 14 */ +#define ADC_SQR3_SQ14_0 (0x01UL << ADC_SQR3_SQ14_Pos) /*!< 0x01000000 */ +#define ADC_SQR3_SQ14_1 (0x02UL << ADC_SQR3_SQ14_Pos) /*!< 0x02000000 */ +#define ADC_SQR3_SQ14_2 (0x04UL << ADC_SQR3_SQ14_Pos) /*!< 0x04000000 */ +#define ADC_SQR3_SQ14_3 (0x08UL << ADC_SQR3_SQ14_Pos) /*!< 0x08000000 */ +#define ADC_SQR3_SQ14_4 (0x10UL << ADC_SQR3_SQ14_Pos) /*!< 0x10000000 */ + +/******************** Bit definition for ADC_SQR4 register ******************/ +#define ADC_SQR4_SQ15_Pos (0U) +#define ADC_SQR4_SQ15_Msk (0x1FUL << ADC_SQR4_SQ15_Pos) /*!< 0x0000001F */ +#define ADC_SQR4_SQ15 ADC_SQR4_SQ15_Msk /*!< ADC group regular sequencer rank 15 */ +#define ADC_SQR4_SQ15_0 (0x01UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000001 */ +#define ADC_SQR4_SQ15_1 (0x02UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000002 */ +#define ADC_SQR4_SQ15_2 (0x04UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000004 */ +#define ADC_SQR4_SQ15_3 (0x08UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000008 */ +#define ADC_SQR4_SQ15_4 (0x10UL << ADC_SQR4_SQ15_Pos) /*!< 0x00000010 */ + +#define ADC_SQR4_SQ16_Pos (6U) +#define ADC_SQR4_SQ16_Msk (0x1FUL << ADC_SQR4_SQ16_Pos) /*!< 0x000007C0 */ +#define ADC_SQR4_SQ16 ADC_SQR4_SQ16_Msk /*!< ADC group regular sequencer rank 16 */ +#define ADC_SQR4_SQ16_0 (0x01UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000040 */ +#define ADC_SQR4_SQ16_1 (0x02UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000080 */ +#define ADC_SQR4_SQ16_2 (0x04UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000100 */ +#define ADC_SQR4_SQ16_3 (0x08UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000200 */ +#define ADC_SQR4_SQ16_4 (0x10UL << ADC_SQR4_SQ16_Pos) /*!< 0x00000400 */ + +/******************** Bit definition for ADC_DR register ********************/ +#define ADC_DR_RDATA_Pos (0U) +#define ADC_DR_RDATA_Msk (0xFFFFUL << ADC_DR_RDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_DR_RDATA ADC_DR_RDATA_Msk /*!< ADC group regular conversion data */ +#define ADC_DR_RDATA_0 (0x0001UL << ADC_DR_RDATA_Pos) /*!< 0x00000001 */ +#define ADC_DR_RDATA_1 (0x0002UL << ADC_DR_RDATA_Pos) /*!< 0x00000002 */ +#define ADC_DR_RDATA_2 (0x0004UL << ADC_DR_RDATA_Pos) /*!< 0x00000004 */ +#define ADC_DR_RDATA_3 (0x0008UL << ADC_DR_RDATA_Pos) /*!< 0x00000008 */ +#define ADC_DR_RDATA_4 (0x0010UL << ADC_DR_RDATA_Pos) /*!< 0x00000010 */ +#define ADC_DR_RDATA_5 (0x0020UL << ADC_DR_RDATA_Pos) /*!< 0x00000020 */ +#define ADC_DR_RDATA_6 (0x0040UL << ADC_DR_RDATA_Pos) /*!< 0x00000040 */ +#define ADC_DR_RDATA_7 (0x0080UL << ADC_DR_RDATA_Pos) /*!< 0x00000080 */ +#define ADC_DR_RDATA_8 (0x0100UL << ADC_DR_RDATA_Pos) /*!< 0x00000100 */ +#define ADC_DR_RDATA_9 (0x0200UL << ADC_DR_RDATA_Pos) /*!< 0x00000200 */ +#define ADC_DR_RDATA_10 (0x0400UL << ADC_DR_RDATA_Pos) /*!< 0x00000400 */ +#define ADC_DR_RDATA_11 (0x0800UL << ADC_DR_RDATA_Pos) /*!< 0x00000800 */ +#define ADC_DR_RDATA_12 (0x1000UL << ADC_DR_RDATA_Pos) /*!< 0x00001000 */ +#define ADC_DR_RDATA_13 (0x2000UL << ADC_DR_RDATA_Pos) /*!< 0x00002000 */ +#define ADC_DR_RDATA_14 (0x4000UL << ADC_DR_RDATA_Pos) /*!< 0x00004000 */ +#define ADC_DR_RDATA_15 (0x8000UL << ADC_DR_RDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JSQR register ******************/ +#define ADC_JSQR_JL_Pos (0U) +#define ADC_JSQR_JL_Msk (0x3UL << ADC_JSQR_JL_Pos) /*!< 0x00000003 */ +#define ADC_JSQR_JL ADC_JSQR_JL_Msk /*!< ADC group injected sequencer scan length */ +#define ADC_JSQR_JL_0 (0x1UL << ADC_JSQR_JL_Pos) /*!< 0x00000001 */ +#define ADC_JSQR_JL_1 (0x2UL << ADC_JSQR_JL_Pos) /*!< 0x00000002 */ + +#define ADC_JSQR_JEXTSEL_Pos (2U) +#define ADC_JSQR_JEXTSEL_Msk (0xFUL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x0000003C */ +#define ADC_JSQR_JEXTSEL ADC_JSQR_JEXTSEL_Msk /*!< ADC group injected external trigger source */ +#define ADC_JSQR_JEXTSEL_0 (0x1UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000004 */ +#define ADC_JSQR_JEXTSEL_1 (0x2UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000008 */ +#define ADC_JSQR_JEXTSEL_2 (0x4UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000010 */ +#define ADC_JSQR_JEXTSEL_3 (0x8UL << ADC_JSQR_JEXTSEL_Pos) /*!< 0x00000020 */ + +#define ADC_JSQR_JEXTEN_Pos (6U) +#define ADC_JSQR_JEXTEN_Msk (0x3UL << ADC_JSQR_JEXTEN_Pos) /*!< 0x000000C0 */ +#define ADC_JSQR_JEXTEN ADC_JSQR_JEXTEN_Msk /*!< ADC group injected external trigger polarity */ +#define ADC_JSQR_JEXTEN_0 (0x1UL << ADC_JSQR_JEXTEN_Pos) /*!< 0x00000040 */ +#define ADC_JSQR_JEXTEN_1 (0x2UL << ADC_JSQR_JEXTEN_Pos) /*!< 0x00000080 */ + +#define ADC_JSQR_JSQ1_Pos (8U) +#define ADC_JSQR_JSQ1_Msk (0x1FUL << ADC_JSQR_JSQ1_Pos) /*!< 0x00001F00 */ +#define ADC_JSQR_JSQ1 ADC_JSQR_JSQ1_Msk /*!< ADC group injected sequencer rank 1 */ +#define ADC_JSQR_JSQ1_0 (0x01UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000100 */ +#define ADC_JSQR_JSQ1_1 (0x02UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000200 */ +#define ADC_JSQR_JSQ1_2 (0x04UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000400 */ +#define ADC_JSQR_JSQ1_3 (0x08UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00000800 */ +#define ADC_JSQR_JSQ1_4 (0x10UL << ADC_JSQR_JSQ1_Pos) /*!< 0x00001000 */ + +#define ADC_JSQR_JSQ2_Pos (14U) +#define ADC_JSQR_JSQ2_Msk (0x1FUL << ADC_JSQR_JSQ2_Pos) /*!< 0x0007C000 */ +#define ADC_JSQR_JSQ2 ADC_JSQR_JSQ2_Msk /*!< ADC group injected sequencer rank 2 */ +#define ADC_JSQR_JSQ2_0 (0x01UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00004000 */ +#define ADC_JSQR_JSQ2_1 (0x02UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00008000 */ +#define ADC_JSQR_JSQ2_2 (0x04UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00010000 */ +#define ADC_JSQR_JSQ2_3 (0x08UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00020000 */ +#define ADC_JSQR_JSQ2_4 (0x10UL << ADC_JSQR_JSQ2_Pos) /*!< 0x00040000 */ + +#define ADC_JSQR_JSQ3_Pos (20U) +#define ADC_JSQR_JSQ3_Msk (0x1FUL << ADC_JSQR_JSQ3_Pos) /*!< 0x01F00000 */ +#define ADC_JSQR_JSQ3 ADC_JSQR_JSQ3_Msk /*!< ADC group injected sequencer rank 3 */ +#define ADC_JSQR_JSQ3_0 (0x01UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00100000 */ +#define ADC_JSQR_JSQ3_1 (0x02UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00200000 */ +#define ADC_JSQR_JSQ3_2 (0x04UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00400000 */ +#define ADC_JSQR_JSQ3_3 (0x08UL << ADC_JSQR_JSQ3_Pos) /*!< 0x00800000 */ +#define ADC_JSQR_JSQ3_4 (0x10UL << ADC_JSQR_JSQ3_Pos) /*!< 0x01000000 */ + +#define ADC_JSQR_JSQ4_Pos (26U) +#define ADC_JSQR_JSQ4_Msk (0x1FUL << ADC_JSQR_JSQ4_Pos) /*!< 0x7C000000 */ +#define ADC_JSQR_JSQ4 ADC_JSQR_JSQ4_Msk /*!< ADC group injected sequencer rank 4 */ +#define ADC_JSQR_JSQ4_0 (0x01UL << ADC_JSQR_JSQ4_Pos) /*!< 0x04000000 */ +#define ADC_JSQR_JSQ4_1 (0x02UL << ADC_JSQR_JSQ4_Pos) /*!< 0x08000000 */ +#define ADC_JSQR_JSQ4_2 (0x04UL << ADC_JSQR_JSQ4_Pos) /*!< 0x10000000 */ +#define ADC_JSQR_JSQ4_3 (0x08UL << ADC_JSQR_JSQ4_Pos) /*!< 0x20000000 */ +#define ADC_JSQR_JSQ4_4 (0x10UL << ADC_JSQR_JSQ4_Pos) /*!< 0x40000000 */ + +/******************** Bit definition for ADC_OFR1 register ******************/ +#define ADC_OFR1_OFFSET1_Pos (0U) +#define ADC_OFR1_OFFSET1_Msk (0xFFFUL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000FFF */ +#define ADC_OFR1_OFFSET1 ADC_OFR1_OFFSET1_Msk /*!< ADC offset number 1 offset level */ +#define ADC_OFR1_OFFSET1_0 (0x001UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000001 */ +#define ADC_OFR1_OFFSET1_1 (0x002UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000002 */ +#define ADC_OFR1_OFFSET1_2 (0x004UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000004 */ +#define ADC_OFR1_OFFSET1_3 (0x008UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000008 */ +#define ADC_OFR1_OFFSET1_4 (0x010UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000010 */ +#define ADC_OFR1_OFFSET1_5 (0x020UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000020 */ +#define ADC_OFR1_OFFSET1_6 (0x040UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000040 */ +#define ADC_OFR1_OFFSET1_7 (0x080UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000080 */ +#define ADC_OFR1_OFFSET1_8 (0x100UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000100 */ +#define ADC_OFR1_OFFSET1_9 (0x200UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000200 */ +#define ADC_OFR1_OFFSET1_10 (0x400UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000400 */ +#define ADC_OFR1_OFFSET1_11 (0x800UL << ADC_OFR1_OFFSET1_Pos) /*!< 0x00000800 */ + +#define ADC_OFR1_OFFSET1_CH_Pos (26U) +#define ADC_OFR1_OFFSET1_CH_Msk (0x1FUL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR1_OFFSET1_CH ADC_OFR1_OFFSET1_CH_Msk /*!< ADC offset number 1 channel selection */ +#define ADC_OFR1_OFFSET1_CH_0 (0x01UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR1_OFFSET1_CH_1 (0x02UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR1_OFFSET1_CH_2 (0x04UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR1_OFFSET1_CH_3 (0x08UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR1_OFFSET1_CH_4 (0x10UL << ADC_OFR1_OFFSET1_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR1_OFFSET1_EN_Pos (31U) +#define ADC_OFR1_OFFSET1_EN_Msk (0x1UL << ADC_OFR1_OFFSET1_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR1_OFFSET1_EN ADC_OFR1_OFFSET1_EN_Msk /*!< ADC offset number 1 enable */ + +/******************** Bit definition for ADC_OFR2 register ******************/ +#define ADC_OFR2_OFFSET2_Pos (0U) +#define ADC_OFR2_OFFSET2_Msk (0xFFFUL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000FFF */ +#define ADC_OFR2_OFFSET2 ADC_OFR2_OFFSET2_Msk /*!< ADC offset number 2 offset level */ +#define ADC_OFR2_OFFSET2_0 (0x001UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000001 */ +#define ADC_OFR2_OFFSET2_1 (0x002UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000002 */ +#define ADC_OFR2_OFFSET2_2 (0x004UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000004 */ +#define ADC_OFR2_OFFSET2_3 (0x008UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000008 */ +#define ADC_OFR2_OFFSET2_4 (0x010UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000010 */ +#define ADC_OFR2_OFFSET2_5 (0x020UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000020 */ +#define ADC_OFR2_OFFSET2_6 (0x040UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000040 */ +#define ADC_OFR2_OFFSET2_7 (0x080UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000080 */ +#define ADC_OFR2_OFFSET2_8 (0x100UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000100 */ +#define ADC_OFR2_OFFSET2_9 (0x200UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000200 */ +#define ADC_OFR2_OFFSET2_10 (0x400UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000400 */ +#define ADC_OFR2_OFFSET2_11 (0x800UL << ADC_OFR2_OFFSET2_Pos) /*!< 0x00000800 */ + +#define ADC_OFR2_OFFSET2_CH_Pos (26U) +#define ADC_OFR2_OFFSET2_CH_Msk (0x1FUL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR2_OFFSET2_CH ADC_OFR2_OFFSET2_CH_Msk /*!< ADC offset number 2 channel selection */ +#define ADC_OFR2_OFFSET2_CH_0 (0x01UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR2_OFFSET2_CH_1 (0x02UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR2_OFFSET2_CH_2 (0x04UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR2_OFFSET2_CH_3 (0x08UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR2_OFFSET2_CH_4 (0x10UL << ADC_OFR2_OFFSET2_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR2_OFFSET2_EN_Pos (31U) +#define ADC_OFR2_OFFSET2_EN_Msk (0x1UL << ADC_OFR2_OFFSET2_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR2_OFFSET2_EN ADC_OFR2_OFFSET2_EN_Msk /*!< ADC offset number 2 enable */ + +/******************** Bit definition for ADC_OFR3 register ******************/ +#define ADC_OFR3_OFFSET3_Pos (0U) +#define ADC_OFR3_OFFSET3_Msk (0xFFFUL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000FFF */ +#define ADC_OFR3_OFFSET3 ADC_OFR3_OFFSET3_Msk /*!< ADC offset number 3 offset level */ +#define ADC_OFR3_OFFSET3_0 (0x001UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000001 */ +#define ADC_OFR3_OFFSET3_1 (0x002UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000002 */ +#define ADC_OFR3_OFFSET3_2 (0x004UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000004 */ +#define ADC_OFR3_OFFSET3_3 (0x008UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000008 */ +#define ADC_OFR3_OFFSET3_4 (0x010UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000010 */ +#define ADC_OFR3_OFFSET3_5 (0x020UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000020 */ +#define ADC_OFR3_OFFSET3_6 (0x040UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000040 */ +#define ADC_OFR3_OFFSET3_7 (0x080UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000080 */ +#define ADC_OFR3_OFFSET3_8 (0x100UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000100 */ +#define ADC_OFR3_OFFSET3_9 (0x200UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000200 */ +#define ADC_OFR3_OFFSET3_10 (0x400UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000400 */ +#define ADC_OFR3_OFFSET3_11 (0x800UL << ADC_OFR3_OFFSET3_Pos) /*!< 0x00000800 */ + +#define ADC_OFR3_OFFSET3_CH_Pos (26U) +#define ADC_OFR3_OFFSET3_CH_Msk (0x1FUL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR3_OFFSET3_CH ADC_OFR3_OFFSET3_CH_Msk /*!< ADC offset number 3 channel selection */ +#define ADC_OFR3_OFFSET3_CH_0 (0x01UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR3_OFFSET3_CH_1 (0x02UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR3_OFFSET3_CH_2 (0x04UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR3_OFFSET3_CH_3 (0x08UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR3_OFFSET3_CH_4 (0x10UL << ADC_OFR3_OFFSET3_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR3_OFFSET3_EN_Pos (31U) +#define ADC_OFR3_OFFSET3_EN_Msk (0x1UL << ADC_OFR3_OFFSET3_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR3_OFFSET3_EN ADC_OFR3_OFFSET3_EN_Msk /*!< ADC offset number 3 enable */ + +/******************** Bit definition for ADC_OFR4 register ******************/ +#define ADC_OFR4_OFFSET4_Pos (0U) +#define ADC_OFR4_OFFSET4_Msk (0xFFFUL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000FFF */ +#define ADC_OFR4_OFFSET4 ADC_OFR4_OFFSET4_Msk /*!< ADC offset number 4 offset level */ +#define ADC_OFR4_OFFSET4_0 (0x001UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000001 */ +#define ADC_OFR4_OFFSET4_1 (0x002UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000002 */ +#define ADC_OFR4_OFFSET4_2 (0x004UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000004 */ +#define ADC_OFR4_OFFSET4_3 (0x008UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000008 */ +#define ADC_OFR4_OFFSET4_4 (0x010UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000010 */ +#define ADC_OFR4_OFFSET4_5 (0x020UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000020 */ +#define ADC_OFR4_OFFSET4_6 (0x040UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000040 */ +#define ADC_OFR4_OFFSET4_7 (0x080UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000080 */ +#define ADC_OFR4_OFFSET4_8 (0x100UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000100 */ +#define ADC_OFR4_OFFSET4_9 (0x200UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000200 */ +#define ADC_OFR4_OFFSET4_10 (0x400UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000400 */ +#define ADC_OFR4_OFFSET4_11 (0x800UL << ADC_OFR4_OFFSET4_Pos) /*!< 0x00000800 */ + +#define ADC_OFR4_OFFSET4_CH_Pos (26U) +#define ADC_OFR4_OFFSET4_CH_Msk (0x1FUL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x7C000000 */ +#define ADC_OFR4_OFFSET4_CH ADC_OFR4_OFFSET4_CH_Msk /*!< ADC offset number 4 channel selection */ +#define ADC_OFR4_OFFSET4_CH_0 (0x01UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x04000000 */ +#define ADC_OFR4_OFFSET4_CH_1 (0x02UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x08000000 */ +#define ADC_OFR4_OFFSET4_CH_2 (0x04UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x10000000 */ +#define ADC_OFR4_OFFSET4_CH_3 (0x08UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x20000000 */ +#define ADC_OFR4_OFFSET4_CH_4 (0x10UL << ADC_OFR4_OFFSET4_CH_Pos) /*!< 0x40000000 */ + +#define ADC_OFR4_OFFSET4_EN_Pos (31U) +#define ADC_OFR4_OFFSET4_EN_Msk (0x1UL << ADC_OFR4_OFFSET4_EN_Pos) /*!< 0x80000000 */ +#define ADC_OFR4_OFFSET4_EN ADC_OFR4_OFFSET4_EN_Msk /*!< ADC offset number 4 enable */ + +/******************** Bit definition for ADC_JDR1 register ******************/ +#define ADC_JDR1_JDATA_Pos (0U) +#define ADC_JDR1_JDATA_Msk (0xFFFFUL << ADC_JDR1_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR1_JDATA ADC_JDR1_JDATA_Msk /*!< ADC group injected sequencer rank 1 conversion data */ +#define ADC_JDR1_JDATA_0 (0x0001UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR1_JDATA_1 (0x0002UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR1_JDATA_2 (0x0004UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR1_JDATA_3 (0x0008UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR1_JDATA_4 (0x0010UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR1_JDATA_5 (0x0020UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR1_JDATA_6 (0x0040UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR1_JDATA_7 (0x0080UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR1_JDATA_8 (0x0100UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR1_JDATA_9 (0x0200UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR1_JDATA_10 (0x0400UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR1_JDATA_11 (0x0800UL << ADC_JDR1_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR1_JDATA_12 (0x1000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR1_JDATA_13 (0x2000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR1_JDATA_14 (0x4000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR1_JDATA_15 (0x8000UL << ADC_JDR1_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JDR2 register ******************/ +#define ADC_JDR2_JDATA_Pos (0U) +#define ADC_JDR2_JDATA_Msk (0xFFFFUL << ADC_JDR2_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR2_JDATA ADC_JDR2_JDATA_Msk /*!< ADC group injected sequencer rank 2 conversion data */ +#define ADC_JDR2_JDATA_0 (0x0001UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR2_JDATA_1 (0x0002UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR2_JDATA_2 (0x0004UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR2_JDATA_3 (0x0008UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR2_JDATA_4 (0x0010UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR2_JDATA_5 (0x0020UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR2_JDATA_6 (0x0040UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR2_JDATA_7 (0x0080UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR2_JDATA_8 (0x0100UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR2_JDATA_9 (0x0200UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR2_JDATA_10 (0x0400UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR2_JDATA_11 (0x0800UL << ADC_JDR2_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR2_JDATA_12 (0x1000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR2_JDATA_13 (0x2000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR2_JDATA_14 (0x4000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR2_JDATA_15 (0x8000UL << ADC_JDR2_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JDR3 register ******************/ +#define ADC_JDR3_JDATA_Pos (0U) +#define ADC_JDR3_JDATA_Msk (0xFFFFUL << ADC_JDR3_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR3_JDATA ADC_JDR3_JDATA_Msk /*!< ADC group injected sequencer rank 3 conversion data */ +#define ADC_JDR3_JDATA_0 (0x0001UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR3_JDATA_1 (0x0002UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR3_JDATA_2 (0x0004UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR3_JDATA_3 (0x0008UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR3_JDATA_4 (0x0010UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR3_JDATA_5 (0x0020UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR3_JDATA_6 (0x0040UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR3_JDATA_7 (0x0080UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR3_JDATA_8 (0x0100UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR3_JDATA_9 (0x0200UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR3_JDATA_10 (0x0400UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR3_JDATA_11 (0x0800UL << ADC_JDR3_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR3_JDATA_12 (0x1000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR3_JDATA_13 (0x2000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR3_JDATA_14 (0x4000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR3_JDATA_15 (0x8000UL << ADC_JDR3_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_JDR4 register ******************/ +#define ADC_JDR4_JDATA_Pos (0U) +#define ADC_JDR4_JDATA_Msk (0xFFFFUL << ADC_JDR4_JDATA_Pos) /*!< 0x0000FFFF */ +#define ADC_JDR4_JDATA ADC_JDR4_JDATA_Msk /*!< ADC group injected sequencer rank 4 conversion data */ +#define ADC_JDR4_JDATA_0 (0x0001UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000001 */ +#define ADC_JDR4_JDATA_1 (0x0002UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000002 */ +#define ADC_JDR4_JDATA_2 (0x0004UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000004 */ +#define ADC_JDR4_JDATA_3 (0x0008UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000008 */ +#define ADC_JDR4_JDATA_4 (0x0010UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000010 */ +#define ADC_JDR4_JDATA_5 (0x0020UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000020 */ +#define ADC_JDR4_JDATA_6 (0x0040UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000040 */ +#define ADC_JDR4_JDATA_7 (0x0080UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000080 */ +#define ADC_JDR4_JDATA_8 (0x0100UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000100 */ +#define ADC_JDR4_JDATA_9 (0x0200UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000200 */ +#define ADC_JDR4_JDATA_10 (0x0400UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000400 */ +#define ADC_JDR4_JDATA_11 (0x0800UL << ADC_JDR4_JDATA_Pos) /*!< 0x00000800 */ +#define ADC_JDR4_JDATA_12 (0x1000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00001000 */ +#define ADC_JDR4_JDATA_13 (0x2000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00002000 */ +#define ADC_JDR4_JDATA_14 (0x4000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00004000 */ +#define ADC_JDR4_JDATA_15 (0x8000UL << ADC_JDR4_JDATA_Pos) /*!< 0x00008000 */ + +/******************** Bit definition for ADC_AWD2CR register ****************/ +#define ADC_AWD2CR_AWD2CH_Pos (0U) +#define ADC_AWD2CR_AWD2CH_Msk (0x7FFFFUL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x0007FFFF */ +#define ADC_AWD2CR_AWD2CH ADC_AWD2CR_AWD2CH_Msk /*!< ADC analog watchdog 2 monitored channel selection */ +#define ADC_AWD2CR_AWD2CH_0 (0x00001UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000001 */ +#define ADC_AWD2CR_AWD2CH_1 (0x00002UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000002 */ +#define ADC_AWD2CR_AWD2CH_2 (0x00004UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000004 */ +#define ADC_AWD2CR_AWD2CH_3 (0x00008UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000008 */ +#define ADC_AWD2CR_AWD2CH_4 (0x00010UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000010 */ +#define ADC_AWD2CR_AWD2CH_5 (0x00020UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000020 */ +#define ADC_AWD2CR_AWD2CH_6 (0x00040UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000040 */ +#define ADC_AWD2CR_AWD2CH_7 (0x00080UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000080 */ +#define ADC_AWD2CR_AWD2CH_8 (0x00100UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000100 */ +#define ADC_AWD2CR_AWD2CH_9 (0x00200UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000200 */ +#define ADC_AWD2CR_AWD2CH_10 (0x00400UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000400 */ +#define ADC_AWD2CR_AWD2CH_11 (0x00800UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00000800 */ +#define ADC_AWD2CR_AWD2CH_12 (0x01000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00001000 */ +#define ADC_AWD2CR_AWD2CH_13 (0x02000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00002000 */ +#define ADC_AWD2CR_AWD2CH_14 (0x04000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00004000 */ +#define ADC_AWD2CR_AWD2CH_15 (0x08000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00008000 */ +#define ADC_AWD2CR_AWD2CH_16 (0x10000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00010000 */ +#define ADC_AWD2CR_AWD2CH_17 (0x20000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00020000 */ +#define ADC_AWD2CR_AWD2CH_18 (0x40000UL << ADC_AWD2CR_AWD2CH_Pos) /*!< 0x00040000 */ + +/******************** Bit definition for ADC_AWD3CR register ****************/ +#define ADC_AWD3CR_AWD3CH_Pos (0U) +#define ADC_AWD3CR_AWD3CH_Msk (0x7FFFFUL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x0007FFFF */ +#define ADC_AWD3CR_AWD3CH ADC_AWD3CR_AWD3CH_Msk /*!< ADC analog watchdog 3 monitored channel selection */ +#define ADC_AWD3CR_AWD3CH_0 (0x00001UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000001 */ +#define ADC_AWD3CR_AWD3CH_1 (0x00002UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000002 */ +#define ADC_AWD3CR_AWD3CH_2 (0x00004UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000004 */ +#define ADC_AWD3CR_AWD3CH_3 (0x00008UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000008 */ +#define ADC_AWD3CR_AWD3CH_4 (0x00010UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000010 */ +#define ADC_AWD3CR_AWD3CH_5 (0x00020UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000020 */ +#define ADC_AWD3CR_AWD3CH_6 (0x00040UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000040 */ +#define ADC_AWD3CR_AWD3CH_7 (0x00080UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000080 */ +#define ADC_AWD3CR_AWD3CH_8 (0x00100UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000100 */ +#define ADC_AWD3CR_AWD3CH_9 (0x00200UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000200 */ +#define ADC_AWD3CR_AWD3CH_10 (0x00400UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000400 */ +#define ADC_AWD3CR_AWD3CH_11 (0x00800UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00000800 */ +#define ADC_AWD3CR_AWD3CH_12 (0x01000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00001000 */ +#define ADC_AWD3CR_AWD3CH_13 (0x02000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00002000 */ +#define ADC_AWD3CR_AWD3CH_14 (0x04000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00004000 */ +#define ADC_AWD3CR_AWD3CH_15 (0x08000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00008000 */ +#define ADC_AWD3CR_AWD3CH_16 (0x10000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00010000 */ +#define ADC_AWD3CR_AWD3CH_17 (0x20000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00020000 */ +#define ADC_AWD3CR_AWD3CH_18 (0x40000UL << ADC_AWD3CR_AWD3CH_Pos) /*!< 0x00040000 */ + +/******************** Bit definition for ADC_DIFSEL register ****************/ +#define ADC_DIFSEL_DIFSEL_Pos (0U) +#define ADC_DIFSEL_DIFSEL_Msk (0x7FFFFUL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x0007FFFF */ +#define ADC_DIFSEL_DIFSEL ADC_DIFSEL_DIFSEL_Msk /*!< ADC channel differential or single-ended mode */ +#define ADC_DIFSEL_DIFSEL_0 (0x00001UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000001 */ +#define ADC_DIFSEL_DIFSEL_1 (0x00002UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000002 */ +#define ADC_DIFSEL_DIFSEL_2 (0x00004UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000004 */ +#define ADC_DIFSEL_DIFSEL_3 (0x00008UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000008 */ +#define ADC_DIFSEL_DIFSEL_4 (0x00010UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000010 */ +#define ADC_DIFSEL_DIFSEL_5 (0x00020UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000020 */ +#define ADC_DIFSEL_DIFSEL_6 (0x00040UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000040 */ +#define ADC_DIFSEL_DIFSEL_7 (0x00080UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000080 */ +#define ADC_DIFSEL_DIFSEL_8 (0x00100UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000100 */ +#define ADC_DIFSEL_DIFSEL_9 (0x00200UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000200 */ +#define ADC_DIFSEL_DIFSEL_10 (0x00400UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000400 */ +#define ADC_DIFSEL_DIFSEL_11 (0x00800UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00000800 */ +#define ADC_DIFSEL_DIFSEL_12 (0x01000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00001000 */ +#define ADC_DIFSEL_DIFSEL_13 (0x02000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00002000 */ +#define ADC_DIFSEL_DIFSEL_14 (0x04000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00004000 */ +#define ADC_DIFSEL_DIFSEL_15 (0x08000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00008000 */ +#define ADC_DIFSEL_DIFSEL_16 (0x10000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00010000 */ +#define ADC_DIFSEL_DIFSEL_17 (0x20000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00020000 */ +#define ADC_DIFSEL_DIFSEL_18 (0x40000UL << ADC_DIFSEL_DIFSEL_Pos) /*!< 0x00040000 */ + +/******************** Bit definition for ADC_CALFACT register ***************/ +#define ADC_CALFACT_CALFACT_S_Pos (0U) +#define ADC_CALFACT_CALFACT_S_Msk (0x7FUL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x0000007F */ +#define ADC_CALFACT_CALFACT_S ADC_CALFACT_CALFACT_S_Msk /*!< ADC calibration factor in single-ended mode */ +#define ADC_CALFACT_CALFACT_S_0 (0x01UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000001 */ +#define ADC_CALFACT_CALFACT_S_1 (0x02UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000002 */ +#define ADC_CALFACT_CALFACT_S_2 (0x04UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000004 */ +#define ADC_CALFACT_CALFACT_S_3 (0x08UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000008 */ +#define ADC_CALFACT_CALFACT_S_4 (0x10UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000010 */ +#define ADC_CALFACT_CALFACT_S_5 (0x20UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000020 */ +#define ADC_CALFACT_CALFACT_S_6 (0x40UL << ADC_CALFACT_CALFACT_S_Pos) /*!< 0x00000040 */ + +#define ADC_CALFACT_CALFACT_D_Pos (16U) +#define ADC_CALFACT_CALFACT_D_Msk (0x7FUL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x007F0000 */ +#define ADC_CALFACT_CALFACT_D ADC_CALFACT_CALFACT_D_Msk /*!< ADC calibration factor in differential mode */ +#define ADC_CALFACT_CALFACT_D_0 (0x01UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00010000 */ +#define ADC_CALFACT_CALFACT_D_1 (0x02UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00020000 */ +#define ADC_CALFACT_CALFACT_D_2 (0x04UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00040000 */ +#define ADC_CALFACT_CALFACT_D_3 (0x08UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00080000 */ +#define ADC_CALFACT_CALFACT_D_4 (0x10UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00100000 */ +#define ADC_CALFACT_CALFACT_D_5 (0x20UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00200000 */ +#define ADC_CALFACT_CALFACT_D_6 (0x40UL << ADC_CALFACT_CALFACT_D_Pos) /*!< 0x00400000 */ + +/************************* ADC Common registers *****************************/ +/******************** Bit definition for ADC_CSR register *******************/ +#define ADC_CSR_ADRDY_MST_Pos (0U) +#define ADC_CSR_ADRDY_MST_Msk (0x1UL << ADC_CSR_ADRDY_MST_Pos) /*!< 0x00000001 */ +#define ADC_CSR_ADRDY_MST ADC_CSR_ADRDY_MST_Msk /*!< ADC multimode master ready flag */ +#define ADC_CSR_EOSMP_MST_Pos (1U) +#define ADC_CSR_EOSMP_MST_Msk (0x1UL << ADC_CSR_EOSMP_MST_Pos) /*!< 0x00000002 */ +#define ADC_CSR_EOSMP_MST ADC_CSR_EOSMP_MST_Msk /*!< ADC multimode master group regular end of sampling flag */ +#define ADC_CSR_EOC_MST_Pos (2U) +#define ADC_CSR_EOC_MST_Msk (0x1UL << ADC_CSR_EOC_MST_Pos) /*!< 0x00000004 */ +#define ADC_CSR_EOC_MST ADC_CSR_EOC_MST_Msk /*!< ADC multimode master group regular end of unitary conversion flag */ +#define ADC_CSR_EOS_MST_Pos (3U) +#define ADC_CSR_EOS_MST_Msk (0x1UL << ADC_CSR_EOS_MST_Pos) /*!< 0x00000008 */ +#define ADC_CSR_EOS_MST ADC_CSR_EOS_MST_Msk /*!< ADC multimode master group regular end of sequence conversions flag */ +#define ADC_CSR_OVR_MST_Pos (4U) +#define ADC_CSR_OVR_MST_Msk (0x1UL << ADC_CSR_OVR_MST_Pos) /*!< 0x00000010 */ +#define ADC_CSR_OVR_MST ADC_CSR_OVR_MST_Msk /*!< ADC multimode master group regular overrun flag */ +#define ADC_CSR_JEOC_MST_Pos (5U) +#define ADC_CSR_JEOC_MST_Msk (0x1UL << ADC_CSR_JEOC_MST_Pos) /*!< 0x00000020 */ +#define ADC_CSR_JEOC_MST ADC_CSR_JEOC_MST_Msk /*!< ADC multimode master group injected end of unitary conversion flag */ +#define ADC_CSR_JEOS_MST_Pos (6U) +#define ADC_CSR_JEOS_MST_Msk (0x1UL << ADC_CSR_JEOS_MST_Pos) /*!< 0x00000040 */ +#define ADC_CSR_JEOS_MST ADC_CSR_JEOS_MST_Msk /*!< ADC multimode master group injected end of sequence conversions flag */ +#define ADC_CSR_AWD1_MST_Pos (7U) +#define ADC_CSR_AWD1_MST_Msk (0x1UL << ADC_CSR_AWD1_MST_Pos) /*!< 0x00000080 */ +#define ADC_CSR_AWD1_MST ADC_CSR_AWD1_MST_Msk /*!< ADC multimode master analog watchdog 1 flag */ +#define ADC_CSR_AWD2_MST_Pos (8U) +#define ADC_CSR_AWD2_MST_Msk (0x1UL << ADC_CSR_AWD2_MST_Pos) /*!< 0x00000100 */ +#define ADC_CSR_AWD2_MST ADC_CSR_AWD2_MST_Msk /*!< ADC multimode master analog watchdog 2 flag */ +#define ADC_CSR_AWD3_MST_Pos (9U) +#define ADC_CSR_AWD3_MST_Msk (0x1UL << ADC_CSR_AWD3_MST_Pos) /*!< 0x00000200 */ +#define ADC_CSR_AWD3_MST ADC_CSR_AWD3_MST_Msk /*!< ADC multimode master analog watchdog 3 flag */ +#define ADC_CSR_JQOVF_MST_Pos (10U) +#define ADC_CSR_JQOVF_MST_Msk (0x1UL << ADC_CSR_JQOVF_MST_Pos) /*!< 0x00000400 */ +#define ADC_CSR_JQOVF_MST ADC_CSR_JQOVF_MST_Msk /*!< ADC multimode master group injected contexts queue overflow flag */ + +#define ADC_CSR_ADRDY_SLV_Pos (16U) +#define ADC_CSR_ADRDY_SLV_Msk (0x1UL << ADC_CSR_ADRDY_SLV_Pos) /*!< 0x00010000 */ +#define ADC_CSR_ADRDY_SLV ADC_CSR_ADRDY_SLV_Msk /*!< ADC multimode slave ready flag */ +#define ADC_CSR_EOSMP_SLV_Pos (17U) +#define ADC_CSR_EOSMP_SLV_Msk (0x1UL << ADC_CSR_EOSMP_SLV_Pos) /*!< 0x00020000 */ +#define ADC_CSR_EOSMP_SLV ADC_CSR_EOSMP_SLV_Msk /*!< ADC multimode slave group regular end of sampling flag */ +#define ADC_CSR_EOC_SLV_Pos (18U) +#define ADC_CSR_EOC_SLV_Msk (0x1UL << ADC_CSR_EOC_SLV_Pos) /*!< 0x00040000 */ +#define ADC_CSR_EOC_SLV ADC_CSR_EOC_SLV_Msk /*!< ADC multimode slave group regular end of unitary conversion flag */ +#define ADC_CSR_EOS_SLV_Pos (19U) +#define ADC_CSR_EOS_SLV_Msk (0x1UL << ADC_CSR_EOS_SLV_Pos) /*!< 0x00080000 */ +#define ADC_CSR_EOS_SLV ADC_CSR_EOS_SLV_Msk /*!< ADC multimode slave group regular end of sequence conversions flag */ +#define ADC_CSR_OVR_SLV_Pos (20U) +#define ADC_CSR_OVR_SLV_Msk (0x1UL << ADC_CSR_OVR_SLV_Pos) /*!< 0x00100000 */ +#define ADC_CSR_OVR_SLV ADC_CSR_OVR_SLV_Msk /*!< ADC multimode slave group regular overrun flag */ +#define ADC_CSR_JEOC_SLV_Pos (21U) +#define ADC_CSR_JEOC_SLV_Msk (0x1UL << ADC_CSR_JEOC_SLV_Pos) /*!< 0x00200000 */ +#define ADC_CSR_JEOC_SLV ADC_CSR_JEOC_SLV_Msk /*!< ADC multimode slave group injected end of unitary conversion flag */ +#define ADC_CSR_JEOS_SLV_Pos (22U) +#define ADC_CSR_JEOS_SLV_Msk (0x1UL << ADC_CSR_JEOS_SLV_Pos) /*!< 0x00400000 */ +#define ADC_CSR_JEOS_SLV ADC_CSR_JEOS_SLV_Msk /*!< ADC multimode slave group injected end of sequence conversions flag */ +#define ADC_CSR_AWD1_SLV_Pos (23U) +#define ADC_CSR_AWD1_SLV_Msk (0x1UL << ADC_CSR_AWD1_SLV_Pos) /*!< 0x00800000 */ +#define ADC_CSR_AWD1_SLV ADC_CSR_AWD1_SLV_Msk /*!< ADC multimode slave analog watchdog 1 flag */ +#define ADC_CSR_AWD2_SLV_Pos (24U) +#define ADC_CSR_AWD2_SLV_Msk (0x1UL << ADC_CSR_AWD2_SLV_Pos) /*!< 0x01000000 */ +#define ADC_CSR_AWD2_SLV ADC_CSR_AWD2_SLV_Msk /*!< ADC multimode slave analog watchdog 2 flag */ +#define ADC_CSR_AWD3_SLV_Pos (25U) +#define ADC_CSR_AWD3_SLV_Msk (0x1UL << ADC_CSR_AWD3_SLV_Pos) /*!< 0x02000000 */ +#define ADC_CSR_AWD3_SLV ADC_CSR_AWD3_SLV_Msk /*!< ADC multimode slave analog watchdog 3 flag */ +#define ADC_CSR_JQOVF_SLV_Pos (26U) +#define ADC_CSR_JQOVF_SLV_Msk (0x1UL << ADC_CSR_JQOVF_SLV_Pos) /*!< 0x04000000 */ +#define ADC_CSR_JQOVF_SLV ADC_CSR_JQOVF_SLV_Msk /*!< ADC multimode slave group injected contexts queue overflow flag */ + +/******************** Bit definition for ADC_CCR register *******************/ +#define ADC_CCR_DUAL_Pos (0U) +#define ADC_CCR_DUAL_Msk (0x1FUL << ADC_CCR_DUAL_Pos) /*!< 0x0000001F */ +#define ADC_CCR_DUAL ADC_CCR_DUAL_Msk /*!< ADC multimode mode selection */ +#define ADC_CCR_DUAL_0 (0x01UL << ADC_CCR_DUAL_Pos) /*!< 0x00000001 */ +#define ADC_CCR_DUAL_1 (0x02UL << ADC_CCR_DUAL_Pos) /*!< 0x00000002 */ +#define ADC_CCR_DUAL_2 (0x04UL << ADC_CCR_DUAL_Pos) /*!< 0x00000004 */ +#define ADC_CCR_DUAL_3 (0x08UL << ADC_CCR_DUAL_Pos) /*!< 0x00000008 */ +#define ADC_CCR_DUAL_4 (0x10UL << ADC_CCR_DUAL_Pos) /*!< 0x00000010 */ + +#define ADC_CCR_DELAY_Pos (8U) +#define ADC_CCR_DELAY_Msk (0xFUL << ADC_CCR_DELAY_Pos) /*!< 0x00000F00 */ +#define ADC_CCR_DELAY ADC_CCR_DELAY_Msk /*!< ADC multimode delay between 2 sampling phases */ +#define ADC_CCR_DELAY_0 (0x1UL << ADC_CCR_DELAY_Pos) /*!< 0x00000100 */ +#define ADC_CCR_DELAY_1 (0x2UL << ADC_CCR_DELAY_Pos) /*!< 0x00000200 */ +#define ADC_CCR_DELAY_2 (0x4UL << ADC_CCR_DELAY_Pos) /*!< 0x00000400 */ +#define ADC_CCR_DELAY_3 (0x8UL << ADC_CCR_DELAY_Pos) /*!< 0x00000800 */ + +#define ADC_CCR_DMACFG_Pos (13U) +#define ADC_CCR_DMACFG_Msk (0x1UL << ADC_CCR_DMACFG_Pos) /*!< 0x00002000 */ +#define ADC_CCR_DMACFG ADC_CCR_DMACFG_Msk /*!< ADC multimode DMA transfer configuration */ + +#define ADC_CCR_MDMA_Pos (14U) +#define ADC_CCR_MDMA_Msk (0x3UL << ADC_CCR_MDMA_Pos) /*!< 0x0000C000 */ +#define ADC_CCR_MDMA ADC_CCR_MDMA_Msk /*!< ADC multimode DMA transfer enable */ +#define ADC_CCR_MDMA_0 (0x1UL << ADC_CCR_MDMA_Pos) /*!< 0x00004000 */ +#define ADC_CCR_MDMA_1 (0x2UL << ADC_CCR_MDMA_Pos) /*!< 0x00008000 */ + +#define ADC_CCR_CKMODE_Pos (16U) +#define ADC_CCR_CKMODE_Msk (0x3UL << ADC_CCR_CKMODE_Pos) /*!< 0x00030000 */ +#define ADC_CCR_CKMODE ADC_CCR_CKMODE_Msk /*!< ADC common clock source and prescaler (prescaler only for clock source synchronous) */ +#define ADC_CCR_CKMODE_0 (0x1UL << ADC_CCR_CKMODE_Pos) /*!< 0x00010000 */ +#define ADC_CCR_CKMODE_1 (0x2UL << ADC_CCR_CKMODE_Pos) /*!< 0x00020000 */ + +#define ADC_CCR_PRESC_Pos (18U) +#define ADC_CCR_PRESC_Msk (0xFUL << ADC_CCR_PRESC_Pos) /*!< 0x003C0000 */ +#define ADC_CCR_PRESC ADC_CCR_PRESC_Msk /*!< ADC common clock prescaler, only for clock source asynchronous */ +#define ADC_CCR_PRESC_0 (0x1UL << ADC_CCR_PRESC_Pos) /*!< 0x00040000 */ +#define ADC_CCR_PRESC_1 (0x2UL << ADC_CCR_PRESC_Pos) /*!< 0x00080000 */ +#define ADC_CCR_PRESC_2 (0x4UL << ADC_CCR_PRESC_Pos) /*!< 0x00100000 */ +#define ADC_CCR_PRESC_3 (0x8UL << ADC_CCR_PRESC_Pos) /*!< 0x00200000 */ + +#define ADC_CCR_VREFEN_Pos (22U) +#define ADC_CCR_VREFEN_Msk (0x1UL << ADC_CCR_VREFEN_Pos) /*!< 0x00400000 */ +#define ADC_CCR_VREFEN ADC_CCR_VREFEN_Msk /*!< ADC internal path to VrefInt enable */ +#define ADC_CCR_TSEN_Pos (23U) +#define ADC_CCR_TSEN_Msk (0x1UL << ADC_CCR_TSEN_Pos) /*!< 0x00800000 */ +#define ADC_CCR_TSEN ADC_CCR_TSEN_Msk /*!< ADC internal path to temperature sensor enable */ +#define ADC_CCR_VBATEN_Pos (24U) +#define ADC_CCR_VBATEN_Msk (0x1UL << ADC_CCR_VBATEN_Pos) /*!< 0x01000000 */ +#define ADC_CCR_VBATEN ADC_CCR_VBATEN_Msk /*!< ADC internal path to battery voltage enable */ + +/******************** Bit definition for ADC_CDR register *******************/ +#define ADC_CDR_RDATA_MST_Pos (0U) +#define ADC_CDR_RDATA_MST_Msk (0xFFFFUL << ADC_CDR_RDATA_MST_Pos) /*!< 0x0000FFFF */ +#define ADC_CDR_RDATA_MST ADC_CDR_RDATA_MST_Msk /*!< ADC multimode master group regular conversion data */ +#define ADC_CDR_RDATA_MST_0 (0x0001UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000001 */ +#define ADC_CDR_RDATA_MST_1 (0x0002UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000002 */ +#define ADC_CDR_RDATA_MST_2 (0x0004UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000004 */ +#define ADC_CDR_RDATA_MST_3 (0x0008UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000008 */ +#define ADC_CDR_RDATA_MST_4 (0x0010UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000010 */ +#define ADC_CDR_RDATA_MST_5 (0x0020UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000020 */ +#define ADC_CDR_RDATA_MST_6 (0x0040UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000040 */ +#define ADC_CDR_RDATA_MST_7 (0x0080UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000080 */ +#define ADC_CDR_RDATA_MST_8 (0x0100UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000100 */ +#define ADC_CDR_RDATA_MST_9 (0x0200UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000200 */ +#define ADC_CDR_RDATA_MST_10 (0x0400UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000400 */ +#define ADC_CDR_RDATA_MST_11 (0x0800UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00000800 */ +#define ADC_CDR_RDATA_MST_12 (0x1000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00001000 */ +#define ADC_CDR_RDATA_MST_13 (0x2000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00002000 */ +#define ADC_CDR_RDATA_MST_14 (0x4000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00004000 */ +#define ADC_CDR_RDATA_MST_15 (0x8000UL << ADC_CDR_RDATA_MST_Pos) /*!< 0x00008000 */ + +#define ADC_CDR_RDATA_SLV_Pos (16U) +#define ADC_CDR_RDATA_SLV_Msk (0xFFFFUL << ADC_CDR_RDATA_SLV_Pos) /*!< 0xFFFF0000 */ +#define ADC_CDR_RDATA_SLV ADC_CDR_RDATA_SLV_Msk /*!< ADC multimode slave group regular conversion data */ +#define ADC_CDR_RDATA_SLV_0 (0x0001UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00010000 */ +#define ADC_CDR_RDATA_SLV_1 (0x0002UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00020000 */ +#define ADC_CDR_RDATA_SLV_2 (0x0004UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00040000 */ +#define ADC_CDR_RDATA_SLV_3 (0x0008UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00080000 */ +#define ADC_CDR_RDATA_SLV_4 (0x0010UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00100000 */ +#define ADC_CDR_RDATA_SLV_5 (0x0020UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00200000 */ +#define ADC_CDR_RDATA_SLV_6 (0x0040UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00400000 */ +#define ADC_CDR_RDATA_SLV_7 (0x0080UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x00800000 */ +#define ADC_CDR_RDATA_SLV_8 (0x0100UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x01000000 */ +#define ADC_CDR_RDATA_SLV_9 (0x0200UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x02000000 */ +#define ADC_CDR_RDATA_SLV_10 (0x0400UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x04000000 */ +#define ADC_CDR_RDATA_SLV_11 (0x0800UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x08000000 */ +#define ADC_CDR_RDATA_SLV_12 (0x1000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x10000000 */ +#define ADC_CDR_RDATA_SLV_13 (0x2000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x20000000 */ +#define ADC_CDR_RDATA_SLV_14 (0x4000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x40000000 */ +#define ADC_CDR_RDATA_SLV_15 (0x8000UL << ADC_CDR_RDATA_SLV_Pos) /*!< 0x80000000 */ + + +/******************************************************************************/ +/* */ +/* CRC calculation unit */ +/* */ +/******************************************************************************/ +/******************* Bit definition for CRC_DR register *********************/ +#define CRC_DR_DR_Pos (0U) +#define CRC_DR_DR_Msk (0xFFFFFFFFUL << CRC_DR_DR_Pos) /*!< 0xFFFFFFFF */ +#define CRC_DR_DR CRC_DR_DR_Msk /*!< Data register bits */ + +/******************* Bit definition for CRC_IDR register ********************/ +#define CRC_IDR_IDR_Pos (0U) +#define CRC_IDR_IDR_Msk (0xFFU << CRC_IDR_IDR_Pos) /*!< 0x000000FF */ +#define CRC_IDR_IDR CRC_IDR_IDR_Msk /*!< General-purpose 8-bit data register bits */ + +/******************** Bit definition for CRC_CR register ********************/ +#define CRC_CR_RESET_Pos (0U) +#define CRC_CR_RESET_Msk (0x1UL << CRC_CR_RESET_Pos) /*!< 0x00000001 */ +#define CRC_CR_RESET CRC_CR_RESET_Msk /*!< RESET the CRC computation unit bit */ +#define CRC_CR_POLYSIZE_Pos (3U) +#define CRC_CR_POLYSIZE_Msk (0x3UL << CRC_CR_POLYSIZE_Pos) /*!< 0x00000018 */ +#define CRC_CR_POLYSIZE CRC_CR_POLYSIZE_Msk /*!< Polynomial size bits */ +#define CRC_CR_POLYSIZE_0 (0x1UL << CRC_CR_POLYSIZE_Pos) /*!< 0x00000008 */ +#define CRC_CR_POLYSIZE_1 (0x2UL << CRC_CR_POLYSIZE_Pos) /*!< 0x00000010 */ +#define CRC_CR_REV_IN_Pos (5U) +#define CRC_CR_REV_IN_Msk (0x3UL << CRC_CR_REV_IN_Pos) /*!< 0x00000060 */ +#define CRC_CR_REV_IN CRC_CR_REV_IN_Msk /*!< REV_IN Reverse Input Data bits */ +#define CRC_CR_REV_IN_0 (0x1UL << CRC_CR_REV_IN_Pos) /*!< 0x00000020 */ +#define CRC_CR_REV_IN_1 (0x2UL << CRC_CR_REV_IN_Pos) /*!< 0x00000040 */ +#define CRC_CR_REV_OUT_Pos (7U) +#define CRC_CR_REV_OUT_Msk (0x1UL << CRC_CR_REV_OUT_Pos) /*!< 0x00000080 */ +#define CRC_CR_REV_OUT CRC_CR_REV_OUT_Msk /*!< REV_OUT Reverse Output Data bits */ + +/******************* Bit definition for CRC_INIT register *******************/ +#define CRC_INIT_INIT_Pos (0U) +#define CRC_INIT_INIT_Msk (0xFFFFFFFFUL << CRC_INIT_INIT_Pos) /*!< 0xFFFFFFFF */ +#define CRC_INIT_INIT CRC_INIT_INIT_Msk /*!< Initial CRC value bits */ + +/******************* Bit definition for CRC_POL register ********************/ +#define CRC_POL_POL_Pos (0U) +#define CRC_POL_POL_Msk (0xFFFFFFFFUL << CRC_POL_POL_Pos) /*!< 0xFFFFFFFF */ +#define CRC_POL_POL CRC_POL_POL_Msk /*!< Coefficients of the polynomial */ + +/******************************************************************************/ +/* */ +/* CRS Clock Recovery System */ +/******************************************************************************/ + +/******************* Bit definition for CRS_CR register *********************/ +#define CRS_CR_SYNCOKIE_Pos (0U) +#define CRS_CR_SYNCOKIE_Msk (0x1UL << CRS_CR_SYNCOKIE_Pos) /*!< 0x00000001 */ +#define CRS_CR_SYNCOKIE CRS_CR_SYNCOKIE_Msk /*!< SYNC event OK interrupt enable */ +#define CRS_CR_SYNCWARNIE_Pos (1U) +#define CRS_CR_SYNCWARNIE_Msk (0x1UL << CRS_CR_SYNCWARNIE_Pos) /*!< 0x00000002 */ +#define CRS_CR_SYNCWARNIE CRS_CR_SYNCWARNIE_Msk /*!< SYNC warning interrupt enable */ +#define CRS_CR_ERRIE_Pos (2U) +#define CRS_CR_ERRIE_Msk (0x1UL << CRS_CR_ERRIE_Pos) /*!< 0x00000004 */ +#define CRS_CR_ERRIE CRS_CR_ERRIE_Msk /*!< SYNC error or trimming error interrupt enable */ +#define CRS_CR_ESYNCIE_Pos (3U) +#define CRS_CR_ESYNCIE_Msk (0x1UL << CRS_CR_ESYNCIE_Pos) /*!< 0x00000008 */ +#define CRS_CR_ESYNCIE CRS_CR_ESYNCIE_Msk /*!< Expected SYNC interrupt enable */ +#define CRS_CR_CEN_Pos (5U) +#define CRS_CR_CEN_Msk (0x1UL << CRS_CR_CEN_Pos) /*!< 0x00000020 */ +#define CRS_CR_CEN CRS_CR_CEN_Msk /*!< Frequency error counter enable */ +#define CRS_CR_AUTOTRIMEN_Pos (6U) +#define CRS_CR_AUTOTRIMEN_Msk (0x1UL << CRS_CR_AUTOTRIMEN_Pos) /*!< 0x00000040 */ +#define CRS_CR_AUTOTRIMEN CRS_CR_AUTOTRIMEN_Msk /*!< Automatic trimming enable */ +#define CRS_CR_SWSYNC_Pos (7U) +#define CRS_CR_SWSYNC_Msk (0x1UL << CRS_CR_SWSYNC_Pos) /*!< 0x00000080 */ +#define CRS_CR_SWSYNC CRS_CR_SWSYNC_Msk /*!< Generate software SYNC event */ +#define CRS_CR_TRIM_Pos (8U) +#define CRS_CR_TRIM_Msk (0x7FUL << CRS_CR_TRIM_Pos) /*!< 0x00007F00 */ +#define CRS_CR_TRIM CRS_CR_TRIM_Msk /*!< TRIM[6:0] HSI48 oscillator smooth trimming */ +#define CRS_CR_TRIM_0 (0x01UL << CRS_CR_TRIM_Pos) /*!< 0x00000100 */ +#define CRS_CR_TRIM_1 (0x02UL << CRS_CR_TRIM_Pos) /*!< 0x00000200 */ +#define CRS_CR_TRIM_2 (0x04UL << CRS_CR_TRIM_Pos) /*!< 0x00000400 */ +#define CRS_CR_TRIM_3 (0x08UL << CRS_CR_TRIM_Pos) /*!< 0x00000800 */ +#define CRS_CR_TRIM_4 (0x10UL << CRS_CR_TRIM_Pos) /*!< 0x00001000 */ +#define CRS_CR_TRIM_5 (0x20UL << CRS_CR_TRIM_Pos) /*!< 0x00002000 */ +#define CRS_CR_TRIM_6 (0x40UL << CRS_CR_TRIM_Pos) /*!< 0x00004000 */ + +/******************* Bit definition for CRS_CFGR register *********************/ +#define CRS_CFGR_RELOAD_Pos (0U) +#define CRS_CFGR_RELOAD_Msk (0xFFFFUL << CRS_CFGR_RELOAD_Pos) /*!< 0x0000FFFF */ +#define CRS_CFGR_RELOAD CRS_CFGR_RELOAD_Msk /*!< Counter reload value */ +#define CRS_CFGR_FELIM_Pos (16U) +#define CRS_CFGR_FELIM_Msk (0xFFUL << CRS_CFGR_FELIM_Pos) /*!< 0x00FF0000 */ +#define CRS_CFGR_FELIM CRS_CFGR_FELIM_Msk /*!< Frequency error limit */ + +#define CRS_CFGR_SYNCDIV_Pos (24U) +#define CRS_CFGR_SYNCDIV_Msk (0x7UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x07000000 */ +#define CRS_CFGR_SYNCDIV CRS_CFGR_SYNCDIV_Msk /*!< SYNC divider */ +#define CRS_CFGR_SYNCDIV_0 (0x1UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x01000000 */ +#define CRS_CFGR_SYNCDIV_1 (0x2UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x02000000 */ +#define CRS_CFGR_SYNCDIV_2 (0x4UL << CRS_CFGR_SYNCDIV_Pos) /*!< 0x04000000 */ + +#define CRS_CFGR_SYNCSRC_Pos (28U) +#define CRS_CFGR_SYNCSRC_Msk (0x3UL << CRS_CFGR_SYNCSRC_Pos) /*!< 0x30000000 */ +#define CRS_CFGR_SYNCSRC CRS_CFGR_SYNCSRC_Msk /*!< SYNC signal source selection */ +#define CRS_CFGR_SYNCSRC_0 (0x1UL << CRS_CFGR_SYNCSRC_Pos) /*!< 0x10000000 */ +#define CRS_CFGR_SYNCSRC_1 (0x2UL << CRS_CFGR_SYNCSRC_Pos) /*!< 0x20000000 */ + +#define CRS_CFGR_SYNCPOL_Pos (31U) +#define CRS_CFGR_SYNCPOL_Msk (0x1UL << CRS_CFGR_SYNCPOL_Pos) /*!< 0x80000000 */ +#define CRS_CFGR_SYNCPOL CRS_CFGR_SYNCPOL_Msk /*!< SYNC polarity selection */ + +/******************* Bit definition for CRS_ISR register *********************/ +#define CRS_ISR_SYNCOKF_Pos (0U) +#define CRS_ISR_SYNCOKF_Msk (0x1UL << CRS_ISR_SYNCOKF_Pos) /*!< 0x00000001 */ +#define CRS_ISR_SYNCOKF CRS_ISR_SYNCOKF_Msk /*!< SYNC event OK flag */ +#define CRS_ISR_SYNCWARNF_Pos (1U) +#define CRS_ISR_SYNCWARNF_Msk (0x1UL << CRS_ISR_SYNCWARNF_Pos) /*!< 0x00000002 */ +#define CRS_ISR_SYNCWARNF CRS_ISR_SYNCWARNF_Msk /*!< SYNC warning flag */ +#define CRS_ISR_ERRF_Pos (2U) +#define CRS_ISR_ERRF_Msk (0x1UL << CRS_ISR_ERRF_Pos) /*!< 0x00000004 */ +#define CRS_ISR_ERRF CRS_ISR_ERRF_Msk /*!< Error flag */ +#define CRS_ISR_ESYNCF_Pos (3U) +#define CRS_ISR_ESYNCF_Msk (0x1UL << CRS_ISR_ESYNCF_Pos) /*!< 0x00000008 */ +#define CRS_ISR_ESYNCF CRS_ISR_ESYNCF_Msk /*!< Expected SYNC flag */ +#define CRS_ISR_SYNCERR_Pos (8U) +#define CRS_ISR_SYNCERR_Msk (0x1UL << CRS_ISR_SYNCERR_Pos) /*!< 0x00000100 */ +#define CRS_ISR_SYNCERR CRS_ISR_SYNCERR_Msk /*!< SYNC error */ +#define CRS_ISR_SYNCMISS_Pos (9U) +#define CRS_ISR_SYNCMISS_Msk (0x1UL << CRS_ISR_SYNCMISS_Pos) /*!< 0x00000200 */ +#define CRS_ISR_SYNCMISS CRS_ISR_SYNCMISS_Msk /*!< SYNC missed */ +#define CRS_ISR_TRIMOVF_Pos (10U) +#define CRS_ISR_TRIMOVF_Msk (0x1UL << CRS_ISR_TRIMOVF_Pos) /*!< 0x00000400 */ +#define CRS_ISR_TRIMOVF CRS_ISR_TRIMOVF_Msk /*!< Trimming overflow or underflow */ +#define CRS_ISR_FEDIR_Pos (15U) +#define CRS_ISR_FEDIR_Msk (0x1UL << CRS_ISR_FEDIR_Pos) /*!< 0x00008000 */ +#define CRS_ISR_FEDIR CRS_ISR_FEDIR_Msk /*!< Frequency error direction */ +#define CRS_ISR_FECAP_Pos (16U) +#define CRS_ISR_FECAP_Msk (0xFFFFUL << CRS_ISR_FECAP_Pos) /*!< 0xFFFF0000 */ +#define CRS_ISR_FECAP CRS_ISR_FECAP_Msk /*!< Frequency error capture */ + +/******************* Bit definition for CRS_ICR register *********************/ +#define CRS_ICR_SYNCOKC_Pos (0U) +#define CRS_ICR_SYNCOKC_Msk (0x1UL << CRS_ICR_SYNCOKC_Pos) /*!< 0x00000001 */ +#define CRS_ICR_SYNCOKC CRS_ICR_SYNCOKC_Msk /*!< SYNC event OK clear flag */ +#define CRS_ICR_SYNCWARNC_Pos (1U) +#define CRS_ICR_SYNCWARNC_Msk (0x1UL << CRS_ICR_SYNCWARNC_Pos) /*!< 0x00000002 */ +#define CRS_ICR_SYNCWARNC CRS_ICR_SYNCWARNC_Msk /*!< SYNC warning clear flag */ +#define CRS_ICR_ERRC_Pos (2U) +#define CRS_ICR_ERRC_Msk (0x1UL << CRS_ICR_ERRC_Pos) /*!< 0x00000004 */ +#define CRS_ICR_ERRC CRS_ICR_ERRC_Msk /*!< Error clear flag */ +#define CRS_ICR_ESYNCC_Pos (3U) +#define CRS_ICR_ESYNCC_Msk (0x1UL << CRS_ICR_ESYNCC_Pos) /*!< 0x00000008 */ +#define CRS_ICR_ESYNCC CRS_ICR_ESYNCC_Msk /*!< Expected SYNC clear flag */ + +/******************************************************************************/ +/* */ +/* Advanced Encryption Standard (AES) */ +/* */ +/******************************************************************************/ +/******************* Bit definition for AES_CR register *********************/ +#define AES_CR_EN_Pos (0U) +#define AES_CR_EN_Msk (0x1UL << AES_CR_EN_Pos) /*!< 0x00000001 */ +#define AES_CR_EN AES_CR_EN_Msk /*!< AES Enable */ +#define AES_CR_DATATYPE_Pos (1U) +#define AES_CR_DATATYPE_Msk (0x3UL << AES_CR_DATATYPE_Pos) /*!< 0x00000006 */ +#define AES_CR_DATATYPE AES_CR_DATATYPE_Msk /*!< Data type selection */ +#define AES_CR_DATATYPE_0 (0x1UL << AES_CR_DATATYPE_Pos) /*!< 0x00000002 */ +#define AES_CR_DATATYPE_1 (0x2UL << AES_CR_DATATYPE_Pos) /*!< 0x00000004 */ + +#define AES_CR_MODE_Pos (3U) +#define AES_CR_MODE_Msk (0x3UL << AES_CR_MODE_Pos) /*!< 0x00000018 */ +#define AES_CR_MODE AES_CR_MODE_Msk /*!< AES Mode Of Operation */ +#define AES_CR_MODE_0 (0x1UL << AES_CR_MODE_Pos) /*!< 0x00000008 */ +#define AES_CR_MODE_1 (0x2UL << AES_CR_MODE_Pos) /*!< 0x00000010 */ + +#define AES_CR_CHMOD_Pos (5U) +#define AES_CR_CHMOD_Msk (0x803UL << AES_CR_CHMOD_Pos) /*!< 0x00010060 */ +#define AES_CR_CHMOD AES_CR_CHMOD_Msk /*!< AES Chaining Mode */ +#define AES_CR_CHMOD_0 (0x001UL << AES_CR_CHMOD_Pos) /*!< 0x00000020 */ +#define AES_CR_CHMOD_1 (0x002UL << AES_CR_CHMOD_Pos) /*!< 0x00000040 */ +#define AES_CR_CHMOD_2 (0x800UL << AES_CR_CHMOD_Pos) /*!< 0x00010000 */ + +#define AES_CR_CCFC_Pos (7U) +#define AES_CR_CCFC_Msk (0x1UL << AES_CR_CCFC_Pos) /*!< 0x00000080 */ +#define AES_CR_CCFC AES_CR_CCFC_Msk /*!< Computation Complete Flag Clear */ +#define AES_CR_ERRC_Pos (8U) +#define AES_CR_ERRC_Msk (0x1UL << AES_CR_ERRC_Pos) /*!< 0x00000100 */ +#define AES_CR_ERRC AES_CR_ERRC_Msk /*!< Error Clear */ +#define AES_CR_CCFIE_Pos (9U) +#define AES_CR_CCFIE_Msk (0x1UL << AES_CR_CCFIE_Pos) /*!< 0x00000200 */ +#define AES_CR_CCFIE AES_CR_CCFIE_Msk /*!< Computation Complete Flag Interrupt Enable */ +#define AES_CR_ERRIE_Pos (10U) +#define AES_CR_ERRIE_Msk (0x1UL << AES_CR_ERRIE_Pos) /*!< 0x00000400 */ +#define AES_CR_ERRIE AES_CR_ERRIE_Msk /*!< Error Interrupt Enable */ +#define AES_CR_DMAINEN_Pos (11U) +#define AES_CR_DMAINEN_Msk (0x1UL << AES_CR_DMAINEN_Pos) /*!< 0x00000800 */ +#define AES_CR_DMAINEN AES_CR_DMAINEN_Msk /*!< Enable data input phase DMA management */ +#define AES_CR_DMAOUTEN_Pos (12U) +#define AES_CR_DMAOUTEN_Msk (0x1UL << AES_CR_DMAOUTEN_Pos) /*!< 0x00001000 */ +#define AES_CR_DMAOUTEN AES_CR_DMAOUTEN_Msk /*!< Enable data output phase DMA management */ + +#define AES_CR_GCMPH_Pos (13U) +#define AES_CR_GCMPH_Msk (0x3UL << AES_CR_GCMPH_Pos) /*!< 0x00006000 */ +#define AES_CR_GCMPH AES_CR_GCMPH_Msk /*!< GCM Phase */ +#define AES_CR_GCMPH_0 (0x1UL << AES_CR_GCMPH_Pos) /*!< 0x00002000 */ +#define AES_CR_GCMPH_1 (0x2UL << AES_CR_GCMPH_Pos) /*!< 0x00004000 */ + +#define AES_CR_KEYSIZE_Pos (18U) +#define AES_CR_KEYSIZE_Msk (0x1UL << AES_CR_KEYSIZE_Pos) /*!< 0x00040000 */ +#define AES_CR_KEYSIZE AES_CR_KEYSIZE_Msk /*!< Key size selection */ + +/******************* Bit definition for AES_SR register *********************/ +#define AES_SR_CCF_Pos (0U) +#define AES_SR_CCF_Msk (0x1UL << AES_SR_CCF_Pos) /*!< 0x00000001 */ +#define AES_SR_CCF AES_SR_CCF_Msk /*!< Computation Complete Flag */ +#define AES_SR_RDERR_Pos (1U) +#define AES_SR_RDERR_Msk (0x1UL << AES_SR_RDERR_Pos) /*!< 0x00000002 */ +#define AES_SR_RDERR AES_SR_RDERR_Msk /*!< Read Error Flag */ +#define AES_SR_WRERR_Pos (2U) +#define AES_SR_WRERR_Msk (0x1UL << AES_SR_WRERR_Pos) /*!< 0x00000004 */ +#define AES_SR_WRERR AES_SR_WRERR_Msk /*!< Write Error Flag */ +#define AES_SR_BUSY_Pos (3U) +#define AES_SR_BUSY_Msk (0x1UL << AES_SR_BUSY_Pos) /*!< 0x00000008 */ +#define AES_SR_BUSY AES_SR_BUSY_Msk /*!< Busy Flag */ + +/******************* Bit definition for AES_DINR register *******************/ +#define AES_DINR_Pos (0U) +#define AES_DINR_Msk (0xFFFFFFFFUL << AES_DINR_Pos) /*!< 0xFFFFFFFF */ +#define AES_DINR AES_DINR_Msk /*!< AES Data Input Register */ + +/******************* Bit definition for AES_DOUTR register ******************/ +#define AES_DOUTR_Pos (0U) +#define AES_DOUTR_Msk (0xFFFFFFFFUL << AES_DOUTR_Pos) /*!< 0xFFFFFFFF */ +#define AES_DOUTR AES_DOUTR_Msk /*!< AES Data Output Register */ + +/******************* Bit definition for AES_KEYR0 register ******************/ +#define AES_KEYR0_Pos (0U) +#define AES_KEYR0_Msk (0xFFFFFFFFUL << AES_KEYR0_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR0 AES_KEYR0_Msk /*!< AES Key Register 0 */ + +/******************* Bit definition for AES_KEYR1 register ******************/ +#define AES_KEYR1_Pos (0U) +#define AES_KEYR1_Msk (0xFFFFFFFFUL << AES_KEYR1_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR1 AES_KEYR1_Msk /*!< AES Key Register 1 */ + +/******************* Bit definition for AES_KEYR2 register ******************/ +#define AES_KEYR2_Pos (0U) +#define AES_KEYR2_Msk (0xFFFFFFFFUL << AES_KEYR2_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR2 AES_KEYR2_Msk /*!< AES Key Register 2 */ + +/******************* Bit definition for AES_KEYR3 register ******************/ +#define AES_KEYR3_Pos (0U) +#define AES_KEYR3_Msk (0xFFFFFFFFUL << AES_KEYR3_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR3 AES_KEYR3_Msk /*!< AES Key Register 3 */ + +/******************* Bit definition for AES_KEYR4 register ******************/ +#define AES_KEYR4_Pos (0U) +#define AES_KEYR4_Msk (0xFFFFFFFFUL << AES_KEYR4_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR4 AES_KEYR4_Msk /*!< AES Key Register 4 */ + +/******************* Bit definition for AES_KEYR5 register ******************/ +#define AES_KEYR5_Pos (0U) +#define AES_KEYR5_Msk (0xFFFFFFFFUL << AES_KEYR5_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR5 AES_KEYR5_Msk /*!< AES Key Register 5 */ + +/******************* Bit definition for AES_KEYR6 register ******************/ +#define AES_KEYR6_Pos (0U) +#define AES_KEYR6_Msk (0xFFFFFFFFUL << AES_KEYR6_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR6 AES_KEYR6_Msk /*!< AES Key Register 6 */ + +/******************* Bit definition for AES_KEYR7 register ******************/ +#define AES_KEYR7_Pos (0U) +#define AES_KEYR7_Msk (0xFFFFFFFFUL << AES_KEYR7_Pos) /*!< 0xFFFFFFFF */ +#define AES_KEYR7 AES_KEYR7_Msk /*!< AES Key Register 7 */ + +/******************* Bit definition for AES_IVR0 register ******************/ +#define AES_IVR0_Pos (0U) +#define AES_IVR0_Msk (0xFFFFFFFFUL << AES_IVR0_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR0 AES_IVR0_Msk /*!< AES Initialization Vector Register 0 */ + +/******************* Bit definition for AES_IVR1 register ******************/ +#define AES_IVR1_Pos (0U) +#define AES_IVR1_Msk (0xFFFFFFFFUL << AES_IVR1_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR1 AES_IVR1_Msk /*!< AES Initialization Vector Register 1 */ + +/******************* Bit definition for AES_IVR2 register ******************/ +#define AES_IVR2_Pos (0U) +#define AES_IVR2_Msk (0xFFFFFFFFUL << AES_IVR2_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR2 AES_IVR2_Msk /*!< AES Initialization Vector Register 2 */ + +/******************* Bit definition for AES_IVR3 register ******************/ +#define AES_IVR3_Pos (0U) +#define AES_IVR3_Msk (0xFFFFFFFFUL << AES_IVR3_Pos) /*!< 0xFFFFFFFF */ +#define AES_IVR3 AES_IVR3_Msk /*!< AES Initialization Vector Register 3 */ + +/******************* Bit definition for AES_SUSP0R register ******************/ +#define AES_SUSP0R_Pos (0U) +#define AES_SUSP0R_Msk (0xFFFFFFFFUL << AES_SUSP0R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP0R AES_SUSP0R_Msk /*!< AES Suspend registers 0 */ + +/******************* Bit definition for AES_SUSP1R register ******************/ +#define AES_SUSP1R_Pos (0U) +#define AES_SUSP1R_Msk (0xFFFFFFFFUL << AES_SUSP1R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP1R AES_SUSP1R_Msk /*!< AES Suspend registers 1 */ + +/******************* Bit definition for AES_SUSP2R register ******************/ +#define AES_SUSP2R_Pos (0U) +#define AES_SUSP2R_Msk (0xFFFFFFFFUL << AES_SUSP2R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP2R AES_SUSP2R_Msk /*!< AES Suspend registers 2 */ + +/******************* Bit definition for AES_SUSP3R register ******************/ +#define AES_SUSP3R_Pos (0U) +#define AES_SUSP3R_Msk (0xFFFFFFFFUL << AES_SUSP3R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP3R AES_SUSP3R_Msk /*!< AES Suspend registers 3 */ + +/******************* Bit definition for AES_SUSP4R register ******************/ +#define AES_SUSP4R_Pos (0U) +#define AES_SUSP4R_Msk (0xFFFFFFFFUL << AES_SUSP4R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP4R AES_SUSP4R_Msk /*!< AES Suspend registers 4 */ + +/******************* Bit definition for AES_SUSP5R register ******************/ +#define AES_SUSP5R_Pos (0U) +#define AES_SUSP5R_Msk (0xFFFFFFFFUL << AES_SUSP5R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP5R AES_SUSP5R_Msk /*!< AES Suspend registers 5 */ + +/******************* Bit definition for AES_SUSP6R register ******************/ +#define AES_SUSP6R_Pos (0U) +#define AES_SUSP6R_Msk (0xFFFFFFFFUL << AES_SUSP6R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP6R AES_SUSP6R_Msk /*!< AES Suspend registers 6 */ + +/******************* Bit definition for AES_SUSP7R register ******************/ +#define AES_SUSP7R_Pos (0U) +#define AES_SUSP7R_Msk (0xFFFFFFFFUL << AES_SUSP7R_Pos) /*!< 0xFFFFFFFF */ +#define AES_SUSP7R AES_SUSP7R_Msk /*!< AES Suspend registers 7 */ + + +/******************************************************************************/ +/* */ +/* DMA Controller (DMA) */ +/* */ +/******************************************************************************/ + +/******************* Bit definition for DMA_ISR register ********************/ +#define DMA_ISR_GIF1_Pos (0U) +#define DMA_ISR_GIF1_Msk (0x1UL << DMA_ISR_GIF1_Pos) /*!< 0x00000001 */ +#define DMA_ISR_GIF1 DMA_ISR_GIF1_Msk /*!< Channel 1 Global interrupt flag */ +#define DMA_ISR_TCIF1_Pos (1U) +#define DMA_ISR_TCIF1_Msk (0x1UL << DMA_ISR_TCIF1_Pos) /*!< 0x00000002 */ +#define DMA_ISR_TCIF1 DMA_ISR_TCIF1_Msk /*!< Channel 1 Transfer Complete flag */ +#define DMA_ISR_HTIF1_Pos (2U) +#define DMA_ISR_HTIF1_Msk (0x1UL << DMA_ISR_HTIF1_Pos) /*!< 0x00000004 */ +#define DMA_ISR_HTIF1 DMA_ISR_HTIF1_Msk /*!< Channel 1 Half Transfer flag */ +#define DMA_ISR_TEIF1_Pos (3U) +#define DMA_ISR_TEIF1_Msk (0x1UL << DMA_ISR_TEIF1_Pos) /*!< 0x00000008 */ +#define DMA_ISR_TEIF1 DMA_ISR_TEIF1_Msk /*!< Channel 1 Transfer Error flag */ +#define DMA_ISR_GIF2_Pos (4U) +#define DMA_ISR_GIF2_Msk (0x1UL << DMA_ISR_GIF2_Pos) /*!< 0x00000010 */ +#define DMA_ISR_GIF2 DMA_ISR_GIF2_Msk /*!< Channel 2 Global interrupt flag */ +#define DMA_ISR_TCIF2_Pos (5U) +#define DMA_ISR_TCIF2_Msk (0x1UL << DMA_ISR_TCIF2_Pos) /*!< 0x00000020 */ +#define DMA_ISR_TCIF2 DMA_ISR_TCIF2_Msk /*!< Channel 2 Transfer Complete flag */ +#define DMA_ISR_HTIF2_Pos (6U) +#define DMA_ISR_HTIF2_Msk (0x1UL << DMA_ISR_HTIF2_Pos) /*!< 0x00000040 */ +#define DMA_ISR_HTIF2 DMA_ISR_HTIF2_Msk /*!< Channel 2 Half Transfer flag */ +#define DMA_ISR_TEIF2_Pos (7U) +#define DMA_ISR_TEIF2_Msk (0x1UL << DMA_ISR_TEIF2_Pos) /*!< 0x00000080 */ +#define DMA_ISR_TEIF2 DMA_ISR_TEIF2_Msk /*!< Channel 2 Transfer Error flag */ +#define DMA_ISR_GIF3_Pos (8U) +#define DMA_ISR_GIF3_Msk (0x1UL << DMA_ISR_GIF3_Pos) /*!< 0x00000100 */ +#define DMA_ISR_GIF3 DMA_ISR_GIF3_Msk /*!< Channel 3 Global interrupt flag */ +#define DMA_ISR_TCIF3_Pos (9U) +#define DMA_ISR_TCIF3_Msk (0x1UL << DMA_ISR_TCIF3_Pos) /*!< 0x00000200 */ +#define DMA_ISR_TCIF3 DMA_ISR_TCIF3_Msk /*!< Channel 3 Transfer Complete flag */ +#define DMA_ISR_HTIF3_Pos (10U) +#define DMA_ISR_HTIF3_Msk (0x1UL << DMA_ISR_HTIF3_Pos) /*!< 0x00000400 */ +#define DMA_ISR_HTIF3 DMA_ISR_HTIF3_Msk /*!< Channel 3 Half Transfer flag */ +#define DMA_ISR_TEIF3_Pos (11U) +#define DMA_ISR_TEIF3_Msk (0x1UL << DMA_ISR_TEIF3_Pos) /*!< 0x00000800 */ +#define DMA_ISR_TEIF3 DMA_ISR_TEIF3_Msk /*!< Channel 3 Transfer Error flag */ +#define DMA_ISR_GIF4_Pos (12U) +#define DMA_ISR_GIF4_Msk (0x1UL << DMA_ISR_GIF4_Pos) /*!< 0x00001000 */ +#define DMA_ISR_GIF4 DMA_ISR_GIF4_Msk /*!< Channel 4 Global interrupt flag */ +#define DMA_ISR_TCIF4_Pos (13U) +#define DMA_ISR_TCIF4_Msk (0x1UL << DMA_ISR_TCIF4_Pos) /*!< 0x00002000 */ +#define DMA_ISR_TCIF4 DMA_ISR_TCIF4_Msk /*!< Channel 4 Transfer Complete flag */ +#define DMA_ISR_HTIF4_Pos (14U) +#define DMA_ISR_HTIF4_Msk (0x1UL << DMA_ISR_HTIF4_Pos) /*!< 0x00004000 */ +#define DMA_ISR_HTIF4 DMA_ISR_HTIF4_Msk /*!< Channel 4 Half Transfer flag */ +#define DMA_ISR_TEIF4_Pos (15U) +#define DMA_ISR_TEIF4_Msk (0x1UL << DMA_ISR_TEIF4_Pos) /*!< 0x00008000 */ +#define DMA_ISR_TEIF4 DMA_ISR_TEIF4_Msk /*!< Channel 4 Transfer Error flag */ +#define DMA_ISR_GIF5_Pos (16U) +#define DMA_ISR_GIF5_Msk (0x1UL << DMA_ISR_GIF5_Pos) /*!< 0x00010000 */ +#define DMA_ISR_GIF5 DMA_ISR_GIF5_Msk /*!< Channel 5 Global interrupt flag */ +#define DMA_ISR_TCIF5_Pos (17U) +#define DMA_ISR_TCIF5_Msk (0x1UL << DMA_ISR_TCIF5_Pos) /*!< 0x00020000 */ +#define DMA_ISR_TCIF5 DMA_ISR_TCIF5_Msk /*!< Channel 5 Transfer Complete flag */ +#define DMA_ISR_HTIF5_Pos (18U) +#define DMA_ISR_HTIF5_Msk (0x1UL << DMA_ISR_HTIF5_Pos) /*!< 0x00040000 */ +#define DMA_ISR_HTIF5 DMA_ISR_HTIF5_Msk /*!< Channel 5 Half Transfer flag */ +#define DMA_ISR_TEIF5_Pos (19U) +#define DMA_ISR_TEIF5_Msk (0x1UL << DMA_ISR_TEIF5_Pos) /*!< 0x00080000 */ +#define DMA_ISR_TEIF5 DMA_ISR_TEIF5_Msk /*!< Channel 5 Transfer Error flag */ +#define DMA_ISR_GIF6_Pos (20U) +#define DMA_ISR_GIF6_Msk (0x1UL << DMA_ISR_GIF6_Pos) /*!< 0x00100000 */ +#define DMA_ISR_GIF6 DMA_ISR_GIF6_Msk /*!< Channel 6 Global interrupt flag */ +#define DMA_ISR_TCIF6_Pos (21U) +#define DMA_ISR_TCIF6_Msk (0x1UL << DMA_ISR_TCIF6_Pos) /*!< 0x00200000 */ +#define DMA_ISR_TCIF6 DMA_ISR_TCIF6_Msk /*!< Channel 6 Transfer Complete flag */ +#define DMA_ISR_HTIF6_Pos (22U) +#define DMA_ISR_HTIF6_Msk (0x1UL << DMA_ISR_HTIF6_Pos) /*!< 0x00400000 */ +#define DMA_ISR_HTIF6 DMA_ISR_HTIF6_Msk /*!< Channel 6 Half Transfer flag */ +#define DMA_ISR_TEIF6_Pos (23U) +#define DMA_ISR_TEIF6_Msk (0x1UL << DMA_ISR_TEIF6_Pos) /*!< 0x00800000 */ +#define DMA_ISR_TEIF6 DMA_ISR_TEIF6_Msk /*!< Channel 6 Transfer Error flag */ +#define DMA_ISR_GIF7_Pos (24U) +#define DMA_ISR_GIF7_Msk (0x1UL << DMA_ISR_GIF7_Pos) /*!< 0x01000000 */ +#define DMA_ISR_GIF7 DMA_ISR_GIF7_Msk /*!< Channel 7 Global interrupt flag */ +#define DMA_ISR_TCIF7_Pos (25U) +#define DMA_ISR_TCIF7_Msk (0x1UL << DMA_ISR_TCIF7_Pos) /*!< 0x02000000 */ +#define DMA_ISR_TCIF7 DMA_ISR_TCIF7_Msk /*!< Channel 7 Transfer Complete flag */ +#define DMA_ISR_HTIF7_Pos (26U) +#define DMA_ISR_HTIF7_Msk (0x1UL << DMA_ISR_HTIF7_Pos) /*!< 0x04000000 */ +#define DMA_ISR_HTIF7 DMA_ISR_HTIF7_Msk /*!< Channel 7 Half Transfer flag */ +#define DMA_ISR_TEIF7_Pos (27U) +#define DMA_ISR_TEIF7_Msk (0x1UL << DMA_ISR_TEIF7_Pos) /*!< 0x08000000 */ +#define DMA_ISR_TEIF7 DMA_ISR_TEIF7_Msk /*!< Channel 7 Transfer Error flag */ + +/******************* Bit definition for DMA_IFCR register *******************/ +#define DMA_IFCR_CGIF1_Pos (0U) +#define DMA_IFCR_CGIF1_Msk (0x1UL << DMA_IFCR_CGIF1_Pos) /*!< 0x00000001 */ +#define DMA_IFCR_CGIF1 DMA_IFCR_CGIF1_Msk /*!< Channel 1 Global interrupt clearr */ +#define DMA_IFCR_CTCIF1_Pos (1U) +#define DMA_IFCR_CTCIF1_Msk (0x1UL << DMA_IFCR_CTCIF1_Pos) /*!< 0x00000002 */ +#define DMA_IFCR_CTCIF1 DMA_IFCR_CTCIF1_Msk /*!< Channel 1 Transfer Complete clear */ +#define DMA_IFCR_CHTIF1_Pos (2U) +#define DMA_IFCR_CHTIF1_Msk (0x1UL << DMA_IFCR_CHTIF1_Pos) /*!< 0x00000004 */ +#define DMA_IFCR_CHTIF1 DMA_IFCR_CHTIF1_Msk /*!< Channel 1 Half Transfer clear */ +#define DMA_IFCR_CTEIF1_Pos (3U) +#define DMA_IFCR_CTEIF1_Msk (0x1UL << DMA_IFCR_CTEIF1_Pos) /*!< 0x00000008 */ +#define DMA_IFCR_CTEIF1 DMA_IFCR_CTEIF1_Msk /*!< Channel 1 Transfer Error clear */ +#define DMA_IFCR_CGIF2_Pos (4U) +#define DMA_IFCR_CGIF2_Msk (0x1UL << DMA_IFCR_CGIF2_Pos) /*!< 0x00000010 */ +#define DMA_IFCR_CGIF2 DMA_IFCR_CGIF2_Msk /*!< Channel 2 Global interrupt clear */ +#define DMA_IFCR_CTCIF2_Pos (5U) +#define DMA_IFCR_CTCIF2_Msk (0x1UL << DMA_IFCR_CTCIF2_Pos) /*!< 0x00000020 */ +#define DMA_IFCR_CTCIF2 DMA_IFCR_CTCIF2_Msk /*!< Channel 2 Transfer Complete clear */ +#define DMA_IFCR_CHTIF2_Pos (6U) +#define DMA_IFCR_CHTIF2_Msk (0x1UL << DMA_IFCR_CHTIF2_Pos) /*!< 0x00000040 */ +#define DMA_IFCR_CHTIF2 DMA_IFCR_CHTIF2_Msk /*!< Channel 2 Half Transfer clear */ +#define DMA_IFCR_CTEIF2_Pos (7U) +#define DMA_IFCR_CTEIF2_Msk (0x1UL << DMA_IFCR_CTEIF2_Pos) /*!< 0x00000080 */ +#define DMA_IFCR_CTEIF2 DMA_IFCR_CTEIF2_Msk /*!< Channel 2 Transfer Error clear */ +#define DMA_IFCR_CGIF3_Pos (8U) +#define DMA_IFCR_CGIF3_Msk (0x1UL << DMA_IFCR_CGIF3_Pos) /*!< 0x00000100 */ +#define DMA_IFCR_CGIF3 DMA_IFCR_CGIF3_Msk /*!< Channel 3 Global interrupt clear */ +#define DMA_IFCR_CTCIF3_Pos (9U) +#define DMA_IFCR_CTCIF3_Msk (0x1UL << DMA_IFCR_CTCIF3_Pos) /*!< 0x00000200 */ +#define DMA_IFCR_CTCIF3 DMA_IFCR_CTCIF3_Msk /*!< Channel 3 Transfer Complete clear */ +#define DMA_IFCR_CHTIF3_Pos (10U) +#define DMA_IFCR_CHTIF3_Msk (0x1UL << DMA_IFCR_CHTIF3_Pos) /*!< 0x00000400 */ +#define DMA_IFCR_CHTIF3 DMA_IFCR_CHTIF3_Msk /*!< Channel 3 Half Transfer clear */ +#define DMA_IFCR_CTEIF3_Pos (11U) +#define DMA_IFCR_CTEIF3_Msk (0x1UL << DMA_IFCR_CTEIF3_Pos) /*!< 0x00000800 */ +#define DMA_IFCR_CTEIF3 DMA_IFCR_CTEIF3_Msk /*!< Channel 3 Transfer Error clear */ +#define DMA_IFCR_CGIF4_Pos (12U) +#define DMA_IFCR_CGIF4_Msk (0x1UL << DMA_IFCR_CGIF4_Pos) /*!< 0x00001000 */ +#define DMA_IFCR_CGIF4 DMA_IFCR_CGIF4_Msk /*!< Channel 4 Global interrupt clear */ +#define DMA_IFCR_CTCIF4_Pos (13U) +#define DMA_IFCR_CTCIF4_Msk (0x1UL << DMA_IFCR_CTCIF4_Pos) /*!< 0x00002000 */ +#define DMA_IFCR_CTCIF4 DMA_IFCR_CTCIF4_Msk /*!< Channel 4 Transfer Complete clear */ +#define DMA_IFCR_CHTIF4_Pos (14U) +#define DMA_IFCR_CHTIF4_Msk (0x1UL << DMA_IFCR_CHTIF4_Pos) /*!< 0x00004000 */ +#define DMA_IFCR_CHTIF4 DMA_IFCR_CHTIF4_Msk /*!< Channel 4 Half Transfer clear */ +#define DMA_IFCR_CTEIF4_Pos (15U) +#define DMA_IFCR_CTEIF4_Msk (0x1UL << DMA_IFCR_CTEIF4_Pos) /*!< 0x00008000 */ +#define DMA_IFCR_CTEIF4 DMA_IFCR_CTEIF4_Msk /*!< Channel 4 Transfer Error clear */ +#define DMA_IFCR_CGIF5_Pos (16U) +#define DMA_IFCR_CGIF5_Msk (0x1UL << DMA_IFCR_CGIF5_Pos) /*!< 0x00010000 */ +#define DMA_IFCR_CGIF5 DMA_IFCR_CGIF5_Msk /*!< Channel 5 Global interrupt clear */ +#define DMA_IFCR_CTCIF5_Pos (17U) +#define DMA_IFCR_CTCIF5_Msk (0x1UL << DMA_IFCR_CTCIF5_Pos) /*!< 0x00020000 */ +#define DMA_IFCR_CTCIF5 DMA_IFCR_CTCIF5_Msk /*!< Channel 5 Transfer Complete clear */ +#define DMA_IFCR_CHTIF5_Pos (18U) +#define DMA_IFCR_CHTIF5_Msk (0x1UL << DMA_IFCR_CHTIF5_Pos) /*!< 0x00040000 */ +#define DMA_IFCR_CHTIF5 DMA_IFCR_CHTIF5_Msk /*!< Channel 5 Half Transfer clear */ +#define DMA_IFCR_CTEIF5_Pos (19U) +#define DMA_IFCR_CTEIF5_Msk (0x1UL << DMA_IFCR_CTEIF5_Pos) /*!< 0x00080000 */ +#define DMA_IFCR_CTEIF5 DMA_IFCR_CTEIF5_Msk /*!< Channel 5 Transfer Error clear */ +#define DMA_IFCR_CGIF6_Pos (20U) +#define DMA_IFCR_CGIF6_Msk (0x1UL << DMA_IFCR_CGIF6_Pos) /*!< 0x00100000 */ +#define DMA_IFCR_CGIF6 DMA_IFCR_CGIF6_Msk /*!< Channel 6 Global interrupt clear */ +#define DMA_IFCR_CTCIF6_Pos (21U) +#define DMA_IFCR_CTCIF6_Msk (0x1UL << DMA_IFCR_CTCIF6_Pos) /*!< 0x00200000 */ +#define DMA_IFCR_CTCIF6 DMA_IFCR_CTCIF6_Msk /*!< Channel 6 Transfer Complete clear */ +#define DMA_IFCR_CHTIF6_Pos (22U) +#define DMA_IFCR_CHTIF6_Msk (0x1UL << DMA_IFCR_CHTIF6_Pos) /*!< 0x00400000 */ +#define DMA_IFCR_CHTIF6 DMA_IFCR_CHTIF6_Msk /*!< Channel 6 Half Transfer clear */ +#define DMA_IFCR_CTEIF6_Pos (23U) +#define DMA_IFCR_CTEIF6_Msk (0x1UL << DMA_IFCR_CTEIF6_Pos) /*!< 0x00800000 */ +#define DMA_IFCR_CTEIF6 DMA_IFCR_CTEIF6_Msk /*!< Channel 6 Transfer Error clear */ +#define DMA_IFCR_CGIF7_Pos (24U) +#define DMA_IFCR_CGIF7_Msk (0x1UL << DMA_IFCR_CGIF7_Pos) /*!< 0x01000000 */ +#define DMA_IFCR_CGIF7 DMA_IFCR_CGIF7_Msk /*!< Channel 7 Global interrupt clear */ +#define DMA_IFCR_CTCIF7_Pos (25U) +#define DMA_IFCR_CTCIF7_Msk (0x1UL << DMA_IFCR_CTCIF7_Pos) /*!< 0x02000000 */ +#define DMA_IFCR_CTCIF7 DMA_IFCR_CTCIF7_Msk /*!< Channel 7 Transfer Complete clear */ +#define DMA_IFCR_CHTIF7_Pos (26U) +#define DMA_IFCR_CHTIF7_Msk (0x1UL << DMA_IFCR_CHTIF7_Pos) /*!< 0x04000000 */ +#define DMA_IFCR_CHTIF7 DMA_IFCR_CHTIF7_Msk /*!< Channel 7 Half Transfer clear */ +#define DMA_IFCR_CTEIF7_Pos (27U) +#define DMA_IFCR_CTEIF7_Msk (0x1UL << DMA_IFCR_CTEIF7_Pos) /*!< 0x08000000 */ +#define DMA_IFCR_CTEIF7 DMA_IFCR_CTEIF7_Msk /*!< Channel 7 Transfer Error clear */ + +/******************* Bit definition for DMA_CCR register ********************/ +#define DMA_CCR_EN_Pos (0U) +#define DMA_CCR_EN_Msk (0x1UL << DMA_CCR_EN_Pos) /*!< 0x00000001 */ +#define DMA_CCR_EN DMA_CCR_EN_Msk /*!< Channel enable */ +#define DMA_CCR_TCIE_Pos (1U) +#define DMA_CCR_TCIE_Msk (0x1UL << DMA_CCR_TCIE_Pos) /*!< 0x00000002 */ +#define DMA_CCR_TCIE DMA_CCR_TCIE_Msk /*!< Transfer complete interrupt enable */ +#define DMA_CCR_HTIE_Pos (2U) +#define DMA_CCR_HTIE_Msk (0x1UL << DMA_CCR_HTIE_Pos) /*!< 0x00000004 */ +#define DMA_CCR_HTIE DMA_CCR_HTIE_Msk /*!< Half Transfer interrupt enable */ +#define DMA_CCR_TEIE_Pos (3U) +#define DMA_CCR_TEIE_Msk (0x1UL << DMA_CCR_TEIE_Pos) /*!< 0x00000008 */ +#define DMA_CCR_TEIE DMA_CCR_TEIE_Msk /*!< Transfer error interrupt enable */ +#define DMA_CCR_DIR_Pos (4U) +#define DMA_CCR_DIR_Msk (0x1UL << DMA_CCR_DIR_Pos) /*!< 0x00000010 */ +#define DMA_CCR_DIR DMA_CCR_DIR_Msk /*!< Data transfer direction */ +#define DMA_CCR_CIRC_Pos (5U) +#define DMA_CCR_CIRC_Msk (0x1UL << DMA_CCR_CIRC_Pos) /*!< 0x00000020 */ +#define DMA_CCR_CIRC DMA_CCR_CIRC_Msk /*!< Circular mode */ +#define DMA_CCR_PINC_Pos (6U) +#define DMA_CCR_PINC_Msk (0x1UL << DMA_CCR_PINC_Pos) /*!< 0x00000040 */ +#define DMA_CCR_PINC DMA_CCR_PINC_Msk /*!< Peripheral increment mode */ +#define DMA_CCR_MINC_Pos (7U) +#define DMA_CCR_MINC_Msk (0x1UL << DMA_CCR_MINC_Pos) /*!< 0x00000080 */ +#define DMA_CCR_MINC DMA_CCR_MINC_Msk /*!< Memory increment mode */ + +#define DMA_CCR_PSIZE_Pos (8U) +#define DMA_CCR_PSIZE_Msk (0x3UL << DMA_CCR_PSIZE_Pos) /*!< 0x00000300 */ +#define DMA_CCR_PSIZE DMA_CCR_PSIZE_Msk /*!< PSIZE[1:0] bits (Peripheral size) */ +#define DMA_CCR_PSIZE_0 (0x1UL << DMA_CCR_PSIZE_Pos) /*!< 0x00000100 */ +#define DMA_CCR_PSIZE_1 (0x2UL << DMA_CCR_PSIZE_Pos) /*!< 0x00000200 */ + +#define DMA_CCR_MSIZE_Pos (10U) +#define DMA_CCR_MSIZE_Msk (0x3UL << DMA_CCR_MSIZE_Pos) /*!< 0x00000C00 */ +#define DMA_CCR_MSIZE DMA_CCR_MSIZE_Msk /*!< MSIZE[1:0] bits (Memory size) */ +#define DMA_CCR_MSIZE_0 (0x1UL << DMA_CCR_MSIZE_Pos) /*!< 0x00000400 */ +#define DMA_CCR_MSIZE_1 (0x2UL << DMA_CCR_MSIZE_Pos) /*!< 0x00000800 */ + +#define DMA_CCR_PL_Pos (12U) +#define DMA_CCR_PL_Msk (0x3UL << DMA_CCR_PL_Pos) /*!< 0x00003000 */ +#define DMA_CCR_PL DMA_CCR_PL_Msk /*!< PL[1:0] bits(Channel Priority level)*/ +#define DMA_CCR_PL_0 (0x1UL << DMA_CCR_PL_Pos) /*!< 0x00001000 */ +#define DMA_CCR_PL_1 (0x2UL << DMA_CCR_PL_Pos) /*!< 0x00002000 */ + +#define DMA_CCR_MEM2MEM_Pos (14U) +#define DMA_CCR_MEM2MEM_Msk (0x1UL << DMA_CCR_MEM2MEM_Pos) /*!< 0x00004000 */ +#define DMA_CCR_MEM2MEM DMA_CCR_MEM2MEM_Msk /*!< Memory to memory mode */ + +/****************** Bit definition for DMA_CNDTR register *******************/ +#define DMA_CNDTR_NDT_Pos (0U) +#define DMA_CNDTR_NDT_Msk (0xFFFFUL << DMA_CNDTR_NDT_Pos) /*!< 0x0000FFFF */ +#define DMA_CNDTR_NDT DMA_CNDTR_NDT_Msk /*!< Number of data to Transfer */ + +/****************** Bit definition for DMA_CPAR register ********************/ +#define DMA_CPAR_PA_Pos (0U) +#define DMA_CPAR_PA_Msk (0xFFFFFFFFUL << DMA_CPAR_PA_Pos) /*!< 0xFFFFFFFF */ +#define DMA_CPAR_PA DMA_CPAR_PA_Msk /*!< Peripheral Address */ + +/****************** Bit definition for DMA_CMAR register ********************/ +#define DMA_CMAR_MA_Pos (0U) +#define DMA_CMAR_MA_Msk (0xFFFFFFFFUL << DMA_CMAR_MA_Pos) /*!< 0xFFFFFFFF */ +#define DMA_CMAR_MA DMA_CMAR_MA_Msk /*!< Memory Address */ + + +/******************* Bit definition for DMA_CSELR register *******************/ +#define DMA_CSELR_C1S_Pos (0U) +#define DMA_CSELR_C1S_Msk (0xFUL << DMA_CSELR_C1S_Pos) /*!< 0x0000000F */ +#define DMA_CSELR_C1S DMA_CSELR_C1S_Msk /*!< Channel 1 Selection */ +#define DMA_CSELR_C2S_Pos (4U) +#define DMA_CSELR_C2S_Msk (0xFUL << DMA_CSELR_C2S_Pos) /*!< 0x000000F0 */ +#define DMA_CSELR_C2S DMA_CSELR_C2S_Msk /*!< Channel 2 Selection */ +#define DMA_CSELR_C3S_Pos (8U) +#define DMA_CSELR_C3S_Msk (0xFUL << DMA_CSELR_C3S_Pos) /*!< 0x00000F00 */ +#define DMA_CSELR_C3S DMA_CSELR_C3S_Msk /*!< Channel 3 Selection */ +#define DMA_CSELR_C4S_Pos (12U) +#define DMA_CSELR_C4S_Msk (0xFUL << DMA_CSELR_C4S_Pos) /*!< 0x0000F000 */ +#define DMA_CSELR_C4S DMA_CSELR_C4S_Msk /*!< Channel 4 Selection */ +#define DMA_CSELR_C5S_Pos (16U) +#define DMA_CSELR_C5S_Msk (0xFUL << DMA_CSELR_C5S_Pos) /*!< 0x000F0000 */ +#define DMA_CSELR_C5S DMA_CSELR_C5S_Msk /*!< Channel 5 Selection */ +#define DMA_CSELR_C6S_Pos (20U) +#define DMA_CSELR_C6S_Msk (0xFUL << DMA_CSELR_C6S_Pos) /*!< 0x00F00000 */ +#define DMA_CSELR_C6S DMA_CSELR_C6S_Msk /*!< Channel 6 Selection */ +#define DMA_CSELR_C7S_Pos (24U) +#define DMA_CSELR_C7S_Msk (0xFUL << DMA_CSELR_C7S_Pos) /*!< 0x0F000000 */ +#define DMA_CSELR_C7S DMA_CSELR_C7S_Msk /*!< Channel 7 Selection */ + +/******************************************************************************/ +/* */ +/* External Interrupt/Event Controller */ +/* */ +/******************************************************************************/ +/******************* Bit definition for EXTI_IMR1 register ******************/ +#define EXTI_IMR1_IM0_Pos (0U) +#define EXTI_IMR1_IM0_Msk (0x1UL << EXTI_IMR1_IM0_Pos) /*!< 0x00000001 */ +#define EXTI_IMR1_IM0 EXTI_IMR1_IM0_Msk /*!< Interrupt Mask on line 0 */ +#define EXTI_IMR1_IM1_Pos (1U) +#define EXTI_IMR1_IM1_Msk (0x1UL << EXTI_IMR1_IM1_Pos) /*!< 0x00000002 */ +#define EXTI_IMR1_IM1 EXTI_IMR1_IM1_Msk /*!< Interrupt Mask on line 1 */ +#define EXTI_IMR1_IM2_Pos (2U) +#define EXTI_IMR1_IM2_Msk (0x1UL << EXTI_IMR1_IM2_Pos) /*!< 0x00000004 */ +#define EXTI_IMR1_IM2 EXTI_IMR1_IM2_Msk /*!< Interrupt Mask on line 2 */ +#define EXTI_IMR1_IM3_Pos (3U) +#define EXTI_IMR1_IM3_Msk (0x1UL << EXTI_IMR1_IM3_Pos) /*!< 0x00000008 */ +#define EXTI_IMR1_IM3 EXTI_IMR1_IM3_Msk /*!< Interrupt Mask on line 3 */ +#define EXTI_IMR1_IM4_Pos (4U) +#define EXTI_IMR1_IM4_Msk (0x1UL << EXTI_IMR1_IM4_Pos) /*!< 0x00000010 */ +#define EXTI_IMR1_IM4 EXTI_IMR1_IM4_Msk /*!< Interrupt Mask on line 4 */ +#define EXTI_IMR1_IM5_Pos (5U) +#define EXTI_IMR1_IM5_Msk (0x1UL << EXTI_IMR1_IM5_Pos) /*!< 0x00000020 */ +#define EXTI_IMR1_IM5 EXTI_IMR1_IM5_Msk /*!< Interrupt Mask on line 5 */ +#define EXTI_IMR1_IM6_Pos (6U) +#define EXTI_IMR1_IM6_Msk (0x1UL << EXTI_IMR1_IM6_Pos) /*!< 0x00000040 */ +#define EXTI_IMR1_IM6 EXTI_IMR1_IM6_Msk /*!< Interrupt Mask on line 6 */ +#define EXTI_IMR1_IM7_Pos (7U) +#define EXTI_IMR1_IM7_Msk (0x1UL << EXTI_IMR1_IM7_Pos) /*!< 0x00000080 */ +#define EXTI_IMR1_IM7 EXTI_IMR1_IM7_Msk /*!< Interrupt Mask on line 7 */ +#define EXTI_IMR1_IM8_Pos (8U) +#define EXTI_IMR1_IM8_Msk (0x1UL << EXTI_IMR1_IM8_Pos) /*!< 0x00000100 */ +#define EXTI_IMR1_IM8 EXTI_IMR1_IM8_Msk /*!< Interrupt Mask on line 8 */ +#define EXTI_IMR1_IM9_Pos (9U) +#define EXTI_IMR1_IM9_Msk (0x1UL << EXTI_IMR1_IM9_Pos) /*!< 0x00000200 */ +#define EXTI_IMR1_IM9 EXTI_IMR1_IM9_Msk /*!< Interrupt Mask on line 9 */ +#define EXTI_IMR1_IM10_Pos (10U) +#define EXTI_IMR1_IM10_Msk (0x1UL << EXTI_IMR1_IM10_Pos) /*!< 0x00000400 */ +#define EXTI_IMR1_IM10 EXTI_IMR1_IM10_Msk /*!< Interrupt Mask on line 10 */ +#define EXTI_IMR1_IM11_Pos (11U) +#define EXTI_IMR1_IM11_Msk (0x1UL << EXTI_IMR1_IM11_Pos) /*!< 0x00000800 */ +#define EXTI_IMR1_IM11 EXTI_IMR1_IM11_Msk /*!< Interrupt Mask on line 11 */ +#define EXTI_IMR1_IM12_Pos (12U) +#define EXTI_IMR1_IM12_Msk (0x1UL << EXTI_IMR1_IM12_Pos) /*!< 0x00001000 */ +#define EXTI_IMR1_IM12 EXTI_IMR1_IM12_Msk /*!< Interrupt Mask on line 12 */ +#define EXTI_IMR1_IM13_Pos (13U) +#define EXTI_IMR1_IM13_Msk (0x1UL << EXTI_IMR1_IM13_Pos) /*!< 0x00002000 */ +#define EXTI_IMR1_IM13 EXTI_IMR1_IM13_Msk /*!< Interrupt Mask on line 13 */ +#define EXTI_IMR1_IM14_Pos (14U) +#define EXTI_IMR1_IM14_Msk (0x1UL << EXTI_IMR1_IM14_Pos) /*!< 0x00004000 */ +#define EXTI_IMR1_IM14 EXTI_IMR1_IM14_Msk /*!< Interrupt Mask on line 14 */ +#define EXTI_IMR1_IM15_Pos (15U) +#define EXTI_IMR1_IM15_Msk (0x1UL << EXTI_IMR1_IM15_Pos) /*!< 0x00008000 */ +#define EXTI_IMR1_IM15 EXTI_IMR1_IM15_Msk /*!< Interrupt Mask on line 15 */ +#define EXTI_IMR1_IM16_Pos (16U) +#define EXTI_IMR1_IM16_Msk (0x1UL << EXTI_IMR1_IM16_Pos) /*!< 0x00010000 */ +#define EXTI_IMR1_IM16 EXTI_IMR1_IM16_Msk /*!< Interrupt Mask on line 16 */ +#define EXTI_IMR1_IM17_Pos (17U) +#define EXTI_IMR1_IM17_Msk (0x1UL << EXTI_IMR1_IM17_Pos) /*!< 0x00020000 */ +#define EXTI_IMR1_IM17 EXTI_IMR1_IM17_Msk /*!< Interrupt Mask on line 17 */ +#define EXTI_IMR1_IM18_Pos (18U) +#define EXTI_IMR1_IM18_Msk (0x1UL << EXTI_IMR1_IM18_Pos) /*!< 0x00040000 */ +#define EXTI_IMR1_IM18 EXTI_IMR1_IM18_Msk /*!< Interrupt Mask on line 18 */ +#define EXTI_IMR1_IM19_Pos (19U) +#define EXTI_IMR1_IM19_Msk (0x1UL << EXTI_IMR1_IM19_Pos) /*!< 0x00080000 */ +#define EXTI_IMR1_IM19 EXTI_IMR1_IM19_Msk /*!< Interrupt Mask on line 19 */ +#define EXTI_IMR1_IM20_Pos (20U) +#define EXTI_IMR1_IM20_Msk (0x1UL << EXTI_IMR1_IM20_Pos) /*!< 0x00100000 */ +#define EXTI_IMR1_IM20 EXTI_IMR1_IM20_Msk /*!< Interrupt Mask on line 20 */ +#define EXTI_IMR1_IM21_Pos (21U) +#define EXTI_IMR1_IM21_Msk (0x1UL << EXTI_IMR1_IM21_Pos) /*!< 0x00200000 */ +#define EXTI_IMR1_IM21 EXTI_IMR1_IM21_Msk /*!< Interrupt Mask on line 21 */ +#define EXTI_IMR1_IM23_Pos (23U) +#define EXTI_IMR1_IM23_Msk (0x1UL << EXTI_IMR1_IM23_Pos) /*!< 0x00800000 */ +#define EXTI_IMR1_IM23 EXTI_IMR1_IM23_Msk /*!< Interrupt Mask on line 23 */ +#define EXTI_IMR1_IM24_Pos (24U) +#define EXTI_IMR1_IM24_Msk (0x1UL << EXTI_IMR1_IM24_Pos) /*!< 0x01000000 */ +#define EXTI_IMR1_IM24 EXTI_IMR1_IM24_Msk /*!< Interrupt Mask on line 24 */ +#define EXTI_IMR1_IM25_Pos (25U) +#define EXTI_IMR1_IM25_Msk (0x1UL << EXTI_IMR1_IM25_Pos) /*!< 0x02000000 */ +#define EXTI_IMR1_IM25 EXTI_IMR1_IM25_Msk /*!< Interrupt Mask on line 25 */ +#define EXTI_IMR1_IM26_Pos (26U) +#define EXTI_IMR1_IM26_Msk (0x1UL << EXTI_IMR1_IM26_Pos) /*!< 0x04000000 */ +#define EXTI_IMR1_IM26 EXTI_IMR1_IM26_Msk /*!< Interrupt Mask on line 26 */ +#define EXTI_IMR1_IM27_Pos (27U) +#define EXTI_IMR1_IM27_Msk (0x1UL << EXTI_IMR1_IM27_Pos) /*!< 0x08000000 */ +#define EXTI_IMR1_IM27 EXTI_IMR1_IM27_Msk /*!< Interrupt Mask on line 27 */ +#define EXTI_IMR1_IM28_Pos (28U) +#define EXTI_IMR1_IM28_Msk (0x1UL << EXTI_IMR1_IM28_Pos) /*!< 0x10000000 */ +#define EXTI_IMR1_IM28 EXTI_IMR1_IM28_Msk /*!< Interrupt Mask on line 28 */ +#define EXTI_IMR1_IM29_Pos (29U) +#define EXTI_IMR1_IM29_Msk (0x1UL << EXTI_IMR1_IM29_Pos) /*!< 0x20000000 */ +#define EXTI_IMR1_IM29 EXTI_IMR1_IM29_Msk /*!< Interrupt Mask on line 29 */ +#define EXTI_IMR1_IM30_Pos (30U) +#define EXTI_IMR1_IM30_Msk (0x1UL << EXTI_IMR1_IM30_Pos) /*!< 0x40000000 */ +#define EXTI_IMR1_IM30 EXTI_IMR1_IM30_Msk /*!< Interrupt Mask on line 30 */ +#define EXTI_IMR1_IM31_Pos (31U) +#define EXTI_IMR1_IM31_Msk (0x1UL << EXTI_IMR1_IM31_Pos) /*!< 0x80000000 */ +#define EXTI_IMR1_IM31 EXTI_IMR1_IM31_Msk /*!< Interrupt Mask on line 31 */ +#define EXTI_IMR1_IM_Pos (0U) +#define EXTI_IMR1_IM_Msk (0x9FFFFFFFUL << EXTI_IMR1_IM_Pos) /*!< 0x9FFFFFFF */ +#define EXTI_IMR1_IM EXTI_IMR1_IM_Msk /*!< Interrupt Mask All */ + +/******************* Bit definition for EXTI_EMR1 register ******************/ +#define EXTI_EMR1_EM0_Pos (0U) +#define EXTI_EMR1_EM0_Msk (0x1UL << EXTI_EMR1_EM0_Pos) /*!< 0x00000001 */ +#define EXTI_EMR1_EM0 EXTI_EMR1_EM0_Msk /*!< Event Mask on line 0 */ +#define EXTI_EMR1_EM1_Pos (1U) +#define EXTI_EMR1_EM1_Msk (0x1UL << EXTI_EMR1_EM1_Pos) /*!< 0x00000002 */ +#define EXTI_EMR1_EM1 EXTI_EMR1_EM1_Msk /*!< Event Mask on line 1 */ +#define EXTI_EMR1_EM2_Pos (2U) +#define EXTI_EMR1_EM2_Msk (0x1UL << EXTI_EMR1_EM2_Pos) /*!< 0x00000004 */ +#define EXTI_EMR1_EM2 EXTI_EMR1_EM2_Msk /*!< Event Mask on line 2 */ +#define EXTI_EMR1_EM3_Pos (3U) +#define EXTI_EMR1_EM3_Msk (0x1UL << EXTI_EMR1_EM3_Pos) /*!< 0x00000008 */ +#define EXTI_EMR1_EM3 EXTI_EMR1_EM3_Msk /*!< Event Mask on line 3 */ +#define EXTI_EMR1_EM4_Pos (4U) +#define EXTI_EMR1_EM4_Msk (0x1UL << EXTI_EMR1_EM4_Pos) /*!< 0x00000010 */ +#define EXTI_EMR1_EM4 EXTI_EMR1_EM4_Msk /*!< Event Mask on line 4 */ +#define EXTI_EMR1_EM5_Pos (5U) +#define EXTI_EMR1_EM5_Msk (0x1UL << EXTI_EMR1_EM5_Pos) /*!< 0x00000020 */ +#define EXTI_EMR1_EM5 EXTI_EMR1_EM5_Msk /*!< Event Mask on line 5 */ +#define EXTI_EMR1_EM6_Pos (6U) +#define EXTI_EMR1_EM6_Msk (0x1UL << EXTI_EMR1_EM6_Pos) /*!< 0x00000040 */ +#define EXTI_EMR1_EM6 EXTI_EMR1_EM6_Msk /*!< Event Mask on line 6 */ +#define EXTI_EMR1_EM7_Pos (7U) +#define EXTI_EMR1_EM7_Msk (0x1UL << EXTI_EMR1_EM7_Pos) /*!< 0x00000080 */ +#define EXTI_EMR1_EM7 EXTI_EMR1_EM7_Msk /*!< Event Mask on line 7 */ +#define EXTI_EMR1_EM8_Pos (8U) +#define EXTI_EMR1_EM8_Msk (0x1UL << EXTI_EMR1_EM8_Pos) /*!< 0x00000100 */ +#define EXTI_EMR1_EM8 EXTI_EMR1_EM8_Msk /*!< Event Mask on line 8 */ +#define EXTI_EMR1_EM9_Pos (9U) +#define EXTI_EMR1_EM9_Msk (0x1UL << EXTI_EMR1_EM9_Pos) /*!< 0x00000200 */ +#define EXTI_EMR1_EM9 EXTI_EMR1_EM9_Msk /*!< Event Mask on line 9 */ +#define EXTI_EMR1_EM10_Pos (10U) +#define EXTI_EMR1_EM10_Msk (0x1UL << EXTI_EMR1_EM10_Pos) /*!< 0x00000400 */ +#define EXTI_EMR1_EM10 EXTI_EMR1_EM10_Msk /*!< Event Mask on line 10 */ +#define EXTI_EMR1_EM11_Pos (11U) +#define EXTI_EMR1_EM11_Msk (0x1UL << EXTI_EMR1_EM11_Pos) /*!< 0x00000800 */ +#define EXTI_EMR1_EM11 EXTI_EMR1_EM11_Msk /*!< Event Mask on line 11 */ +#define EXTI_EMR1_EM12_Pos (12U) +#define EXTI_EMR1_EM12_Msk (0x1UL << EXTI_EMR1_EM12_Pos) /*!< 0x00001000 */ +#define EXTI_EMR1_EM12 EXTI_EMR1_EM12_Msk /*!< Event Mask on line 12 */ +#define EXTI_EMR1_EM13_Pos (13U) +#define EXTI_EMR1_EM13_Msk (0x1UL << EXTI_EMR1_EM13_Pos) /*!< 0x00002000 */ +#define EXTI_EMR1_EM13 EXTI_EMR1_EM13_Msk /*!< Event Mask on line 13 */ +#define EXTI_EMR1_EM14_Pos (14U) +#define EXTI_EMR1_EM14_Msk (0x1UL << EXTI_EMR1_EM14_Pos) /*!< 0x00004000 */ +#define EXTI_EMR1_EM14 EXTI_EMR1_EM14_Msk /*!< Event Mask on line 14 */ +#define EXTI_EMR1_EM15_Pos (15U) +#define EXTI_EMR1_EM15_Msk (0x1UL << EXTI_EMR1_EM15_Pos) /*!< 0x00008000 */ +#define EXTI_EMR1_EM15 EXTI_EMR1_EM15_Msk /*!< Event Mask on line 15 */ +#define EXTI_EMR1_EM16_Pos (16U) +#define EXTI_EMR1_EM16_Msk (0x1UL << EXTI_EMR1_EM16_Pos) /*!< 0x00010000 */ +#define EXTI_EMR1_EM16 EXTI_EMR1_EM16_Msk /*!< Event Mask on line 16 */ +#define EXTI_EMR1_EM17_Pos (17U) +#define EXTI_EMR1_EM17_Msk (0x1UL << EXTI_EMR1_EM17_Pos) /*!< 0x00020000 */ +#define EXTI_EMR1_EM17 EXTI_EMR1_EM17_Msk /*!< Event Mask on line 17 */ +#define EXTI_EMR1_EM18_Pos (18U) +#define EXTI_EMR1_EM18_Msk (0x1UL << EXTI_EMR1_EM18_Pos) /*!< 0x00040000 */ +#define EXTI_EMR1_EM18 EXTI_EMR1_EM18_Msk /*!< Event Mask on line 18 */ +#define EXTI_EMR1_EM19_Pos (19U) +#define EXTI_EMR1_EM19_Msk (0x1UL << EXTI_EMR1_EM19_Pos) /*!< 0x00080000 */ +#define EXTI_EMR1_EM19 EXTI_EMR1_EM19_Msk /*!< Event Mask on line 19 */ +#define EXTI_EMR1_EM20_Pos (20U) +#define EXTI_EMR1_EM20_Msk (0x1UL << EXTI_EMR1_EM20_Pos) /*!< 0x00100000 */ +#define EXTI_EMR1_EM20 EXTI_EMR1_EM20_Msk /*!< Event Mask on line 20 */ +#define EXTI_EMR1_EM21_Pos (21U) +#define EXTI_EMR1_EM21_Msk (0x1UL << EXTI_EMR1_EM21_Pos) /*!< 0x00200000 */ +#define EXTI_EMR1_EM21 EXTI_EMR1_EM21_Msk /*!< Event Mask on line 21 */ +#define EXTI_EMR1_EM23_Pos (23U) +#define EXTI_EMR1_EM23_Msk (0x1UL << EXTI_EMR1_EM23_Pos) /*!< 0x00800000 */ +#define EXTI_EMR1_EM23 EXTI_EMR1_EM23_Msk /*!< Event Mask on line 23 */ +#define EXTI_EMR1_EM24_Pos (24U) +#define EXTI_EMR1_EM24_Msk (0x1UL << EXTI_EMR1_EM24_Pos) /*!< 0x01000000 */ +#define EXTI_EMR1_EM24 EXTI_EMR1_EM24_Msk /*!< Event Mask on line 24 */ +#define EXTI_EMR1_EM25_Pos (25U) +#define EXTI_EMR1_EM25_Msk (0x1UL << EXTI_EMR1_EM25_Pos) /*!< 0x02000000 */ +#define EXTI_EMR1_EM25 EXTI_EMR1_EM25_Msk /*!< Event Mask on line 25 */ +#define EXTI_EMR1_EM26_Pos (26U) +#define EXTI_EMR1_EM26_Msk (0x1UL << EXTI_EMR1_EM26_Pos) /*!< 0x04000000 */ +#define EXTI_EMR1_EM26 EXTI_EMR1_EM26_Msk /*!< Event Mask on line 26 */ +#define EXTI_EMR1_EM27_Pos (27U) +#define EXTI_EMR1_EM27_Msk (0x1UL << EXTI_EMR1_EM27_Pos) /*!< 0x08000000 */ +#define EXTI_EMR1_EM27 EXTI_EMR1_EM27_Msk /*!< Event Mask on line 27 */ +#define EXTI_EMR1_EM28_Pos (28U) +#define EXTI_EMR1_EM28_Msk (0x1UL << EXTI_EMR1_EM28_Pos) /*!< 0x10000000 */ +#define EXTI_EMR1_EM28 EXTI_EMR1_EM28_Msk /*!< Event Mask on line 28 */ +#define EXTI_EMR1_EM31_Pos (31U) +#define EXTI_EMR1_EM31_Msk (0x1UL << EXTI_EMR1_EM31_Pos) /*!< 0x80000000 */ +#define EXTI_EMR1_EM31 EXTI_EMR1_EM31_Msk /*!< Event Mask on line 31 */ + +/****************** Bit definition for EXTI_RTSR1 register ******************/ +#define EXTI_RTSR1_RT0_Pos (0U) +#define EXTI_RTSR1_RT0_Msk (0x1UL << EXTI_RTSR1_RT0_Pos) /*!< 0x00000001 */ +#define EXTI_RTSR1_RT0 EXTI_RTSR1_RT0_Msk /*!< Rising trigger event configuration bit of line 0 */ +#define EXTI_RTSR1_RT1_Pos (1U) +#define EXTI_RTSR1_RT1_Msk (0x1UL << EXTI_RTSR1_RT1_Pos) /*!< 0x00000002 */ +#define EXTI_RTSR1_RT1 EXTI_RTSR1_RT1_Msk /*!< Rising trigger event configuration bit of line 1 */ +#define EXTI_RTSR1_RT2_Pos (2U) +#define EXTI_RTSR1_RT2_Msk (0x1UL << EXTI_RTSR1_RT2_Pos) /*!< 0x00000004 */ +#define EXTI_RTSR1_RT2 EXTI_RTSR1_RT2_Msk /*!< Rising trigger event configuration bit of line 2 */ +#define EXTI_RTSR1_RT3_Pos (3U) +#define EXTI_RTSR1_RT3_Msk (0x1UL << EXTI_RTSR1_RT3_Pos) /*!< 0x00000008 */ +#define EXTI_RTSR1_RT3 EXTI_RTSR1_RT3_Msk /*!< Rising trigger event configuration bit of line 3 */ +#define EXTI_RTSR1_RT4_Pos (4U) +#define EXTI_RTSR1_RT4_Msk (0x1UL << EXTI_RTSR1_RT4_Pos) /*!< 0x00000010 */ +#define EXTI_RTSR1_RT4 EXTI_RTSR1_RT4_Msk /*!< Rising trigger event configuration bit of line 4 */ +#define EXTI_RTSR1_RT5_Pos (5U) +#define EXTI_RTSR1_RT5_Msk (0x1UL << EXTI_RTSR1_RT5_Pos) /*!< 0x00000020 */ +#define EXTI_RTSR1_RT5 EXTI_RTSR1_RT5_Msk /*!< Rising trigger event configuration bit of line 5 */ +#define EXTI_RTSR1_RT6_Pos (6U) +#define EXTI_RTSR1_RT6_Msk (0x1UL << EXTI_RTSR1_RT6_Pos) /*!< 0x00000040 */ +#define EXTI_RTSR1_RT6 EXTI_RTSR1_RT6_Msk /*!< Rising trigger event configuration bit of line 6 */ +#define EXTI_RTSR1_RT7_Pos (7U) +#define EXTI_RTSR1_RT7_Msk (0x1UL << EXTI_RTSR1_RT7_Pos) /*!< 0x00000080 */ +#define EXTI_RTSR1_RT7 EXTI_RTSR1_RT7_Msk /*!< Rising trigger event configuration bit of line 7 */ +#define EXTI_RTSR1_RT8_Pos (8U) +#define EXTI_RTSR1_RT8_Msk (0x1UL << EXTI_RTSR1_RT8_Pos) /*!< 0x00000100 */ +#define EXTI_RTSR1_RT8 EXTI_RTSR1_RT8_Msk /*!< Rising trigger event configuration bit of line 8 */ +#define EXTI_RTSR1_RT9_Pos (9U) +#define EXTI_RTSR1_RT9_Msk (0x1UL << EXTI_RTSR1_RT9_Pos) /*!< 0x00000200 */ +#define EXTI_RTSR1_RT9 EXTI_RTSR1_RT9_Msk /*!< Rising trigger event configuration bit of line 9 */ +#define EXTI_RTSR1_RT10_Pos (10U) +#define EXTI_RTSR1_RT10_Msk (0x1UL << EXTI_RTSR1_RT10_Pos) /*!< 0x00000400 */ +#define EXTI_RTSR1_RT10 EXTI_RTSR1_RT10_Msk /*!< Rising trigger event configuration bit of line 10 */ +#define EXTI_RTSR1_RT11_Pos (11U) +#define EXTI_RTSR1_RT11_Msk (0x1UL << EXTI_RTSR1_RT11_Pos) /*!< 0x00000800 */ +#define EXTI_RTSR1_RT11 EXTI_RTSR1_RT11_Msk /*!< Rising trigger event configuration bit of line 11 */ +#define EXTI_RTSR1_RT12_Pos (12U) +#define EXTI_RTSR1_RT12_Msk (0x1UL << EXTI_RTSR1_RT12_Pos) /*!< 0x00001000 */ +#define EXTI_RTSR1_RT12 EXTI_RTSR1_RT12_Msk /*!< Rising trigger event configuration bit of line 12 */ +#define EXTI_RTSR1_RT13_Pos (13U) +#define EXTI_RTSR1_RT13_Msk (0x1UL << EXTI_RTSR1_RT13_Pos) /*!< 0x00002000 */ +#define EXTI_RTSR1_RT13 EXTI_RTSR1_RT13_Msk /*!< Rising trigger event configuration bit of line 13 */ +#define EXTI_RTSR1_RT14_Pos (14U) +#define EXTI_RTSR1_RT14_Msk (0x1UL << EXTI_RTSR1_RT14_Pos) /*!< 0x00004000 */ +#define EXTI_RTSR1_RT14 EXTI_RTSR1_RT14_Msk /*!< Rising trigger event configuration bit of line 14 */ +#define EXTI_RTSR1_RT15_Pos (15U) +#define EXTI_RTSR1_RT15_Msk (0x1UL << EXTI_RTSR1_RT15_Pos) /*!< 0x00008000 */ +#define EXTI_RTSR1_RT15 EXTI_RTSR1_RT15_Msk /*!< Rising trigger event configuration bit of line 15 */ +#define EXTI_RTSR1_RT16_Pos (16U) +#define EXTI_RTSR1_RT16_Msk (0x1UL << EXTI_RTSR1_RT16_Pos) /*!< 0x00010000 */ +#define EXTI_RTSR1_RT16 EXTI_RTSR1_RT16_Msk /*!< Rising trigger event configuration bit of line 16 */ +#define EXTI_RTSR1_RT18_Pos (18U) +#define EXTI_RTSR1_RT18_Msk (0x1UL << EXTI_RTSR1_RT18_Pos) /*!< 0x00040000 */ +#define EXTI_RTSR1_RT18 EXTI_RTSR1_RT18_Msk /*!< Rising trigger event configuration bit of line 18 */ +#define EXTI_RTSR1_RT19_Pos (19U) +#define EXTI_RTSR1_RT19_Msk (0x1UL << EXTI_RTSR1_RT19_Pos) /*!< 0x00080000 */ +#define EXTI_RTSR1_RT19 EXTI_RTSR1_RT19_Msk /*!< Rising trigger event configuration bit of line 19 */ +#define EXTI_RTSR1_RT20_Pos (20U) +#define EXTI_RTSR1_RT20_Msk (0x1UL << EXTI_RTSR1_RT20_Pos) /*!< 0x00100000 */ +#define EXTI_RTSR1_RT20 EXTI_RTSR1_RT20_Msk /*!< Rising trigger event configuration bit of line 20 */ +#define EXTI_RTSR1_RT21_Pos (21U) +#define EXTI_RTSR1_RT21_Msk (0x1UL << EXTI_RTSR1_RT21_Pos) /*!< 0x00200000 */ +#define EXTI_RTSR1_RT21 EXTI_RTSR1_RT21_Msk /*!< Rising trigger event configuration bit of line 21 */ + +/****************** Bit definition for EXTI_FTSR1 register ******************/ +#define EXTI_FTSR1_FT0_Pos (0U) +#define EXTI_FTSR1_FT0_Msk (0x1UL << EXTI_FTSR1_FT0_Pos) /*!< 0x00000001 */ +#define EXTI_FTSR1_FT0 EXTI_FTSR1_FT0_Msk /*!< Falling trigger event configuration bit of line 0 */ +#define EXTI_FTSR1_FT1_Pos (1U) +#define EXTI_FTSR1_FT1_Msk (0x1UL << EXTI_FTSR1_FT1_Pos) /*!< 0x00000002 */ +#define EXTI_FTSR1_FT1 EXTI_FTSR1_FT1_Msk /*!< Falling trigger event configuration bit of line 1 */ +#define EXTI_FTSR1_FT2_Pos (2U) +#define EXTI_FTSR1_FT2_Msk (0x1UL << EXTI_FTSR1_FT2_Pos) /*!< 0x00000004 */ +#define EXTI_FTSR1_FT2 EXTI_FTSR1_FT2_Msk /*!< Falling trigger event configuration bit of line 2 */ +#define EXTI_FTSR1_FT3_Pos (3U) +#define EXTI_FTSR1_FT3_Msk (0x1UL << EXTI_FTSR1_FT3_Pos) /*!< 0x00000008 */ +#define EXTI_FTSR1_FT3 EXTI_FTSR1_FT3_Msk /*!< Falling trigger event configuration bit of line 3 */ +#define EXTI_FTSR1_FT4_Pos (4U) +#define EXTI_FTSR1_FT4_Msk (0x1UL << EXTI_FTSR1_FT4_Pos) /*!< 0x00000010 */ +#define EXTI_FTSR1_FT4 EXTI_FTSR1_FT4_Msk /*!< Falling trigger event configuration bit of line 4 */ +#define EXTI_FTSR1_FT5_Pos (5U) +#define EXTI_FTSR1_FT5_Msk (0x1UL << EXTI_FTSR1_FT5_Pos) /*!< 0x00000020 */ +#define EXTI_FTSR1_FT5 EXTI_FTSR1_FT5_Msk /*!< Falling trigger event configuration bit of line 5 */ +#define EXTI_FTSR1_FT6_Pos (6U) +#define EXTI_FTSR1_FT6_Msk (0x1UL << EXTI_FTSR1_FT6_Pos) /*!< 0x00000040 */ +#define EXTI_FTSR1_FT6 EXTI_FTSR1_FT6_Msk /*!< Falling trigger event configuration bit of line 6 */ +#define EXTI_FTSR1_FT7_Pos (7U) +#define EXTI_FTSR1_FT7_Msk (0x1UL << EXTI_FTSR1_FT7_Pos) /*!< 0x00000080 */ +#define EXTI_FTSR1_FT7 EXTI_FTSR1_FT7_Msk /*!< Falling trigger event configuration bit of line 7 */ +#define EXTI_FTSR1_FT8_Pos (8U) +#define EXTI_FTSR1_FT8_Msk (0x1UL << EXTI_FTSR1_FT8_Pos) /*!< 0x00000100 */ +#define EXTI_FTSR1_FT8 EXTI_FTSR1_FT8_Msk /*!< Falling trigger event configuration bit of line 8 */ +#define EXTI_FTSR1_FT9_Pos (9U) +#define EXTI_FTSR1_FT9_Msk (0x1UL << EXTI_FTSR1_FT9_Pos) /*!< 0x00000200 */ +#define EXTI_FTSR1_FT9 EXTI_FTSR1_FT9_Msk /*!< Falling trigger event configuration bit of line 9 */ +#define EXTI_FTSR1_FT10_Pos (10U) +#define EXTI_FTSR1_FT10_Msk (0x1UL << EXTI_FTSR1_FT10_Pos) /*!< 0x00000400 */ +#define EXTI_FTSR1_FT10 EXTI_FTSR1_FT10_Msk /*!< Falling trigger event configuration bit of line 10 */ +#define EXTI_FTSR1_FT11_Pos (11U) +#define EXTI_FTSR1_FT11_Msk (0x1UL << EXTI_FTSR1_FT11_Pos) /*!< 0x00000800 */ +#define EXTI_FTSR1_FT11 EXTI_FTSR1_FT11_Msk /*!< Falling trigger event configuration bit of line 11 */ +#define EXTI_FTSR1_FT12_Pos (12U) +#define EXTI_FTSR1_FT12_Msk (0x1UL << EXTI_FTSR1_FT12_Pos) /*!< 0x00001000 */ +#define EXTI_FTSR1_FT12 EXTI_FTSR1_FT12_Msk /*!< Falling trigger event configuration bit of line 12 */ +#define EXTI_FTSR1_FT13_Pos (13U) +#define EXTI_FTSR1_FT13_Msk (0x1UL << EXTI_FTSR1_FT13_Pos) /*!< 0x00002000 */ +#define EXTI_FTSR1_FT13 EXTI_FTSR1_FT13_Msk /*!< Falling trigger event configuration bit of line 13 */ +#define EXTI_FTSR1_FT14_Pos (14U) +#define EXTI_FTSR1_FT14_Msk (0x1UL << EXTI_FTSR1_FT14_Pos) /*!< 0x00004000 */ +#define EXTI_FTSR1_FT14 EXTI_FTSR1_FT14_Msk /*!< Falling trigger event configuration bit of line 14 */ +#define EXTI_FTSR1_FT15_Pos (15U) +#define EXTI_FTSR1_FT15_Msk (0x1UL << EXTI_FTSR1_FT15_Pos) /*!< 0x00008000 */ +#define EXTI_FTSR1_FT15 EXTI_FTSR1_FT15_Msk /*!< Falling trigger event configuration bit of line 15 */ +#define EXTI_FTSR1_FT16_Pos (16U) +#define EXTI_FTSR1_FT16_Msk (0x1UL << EXTI_FTSR1_FT16_Pos) /*!< 0x00010000 */ +#define EXTI_FTSR1_FT16 EXTI_FTSR1_FT16_Msk /*!< Falling trigger event configuration bit of line 16 */ +#define EXTI_FTSR1_FT18_Pos (18U) +#define EXTI_FTSR1_FT18_Msk (0x1UL << EXTI_FTSR1_FT18_Pos) /*!< 0x00040000 */ +#define EXTI_FTSR1_FT18 EXTI_FTSR1_FT18_Msk /*!< Falling trigger event configuration bit of line 18 */ +#define EXTI_FTSR1_FT19_Pos (19U) +#define EXTI_FTSR1_FT19_Msk (0x1UL << EXTI_FTSR1_FT19_Pos) /*!< 0x00080000 */ +#define EXTI_FTSR1_FT19 EXTI_FTSR1_FT19_Msk /*!< Falling trigger event configuration bit of line 19 */ +#define EXTI_FTSR1_FT20_Pos (20U) +#define EXTI_FTSR1_FT20_Msk (0x1UL << EXTI_FTSR1_FT20_Pos) /*!< 0x00100000 */ +#define EXTI_FTSR1_FT20 EXTI_FTSR1_FT20_Msk /*!< Falling trigger event configuration bit of line 20 */ +#define EXTI_FTSR1_FT21_Pos (21U) +#define EXTI_FTSR1_FT21_Msk (0x1UL << EXTI_FTSR1_FT21_Pos) /*!< 0x00200000 */ +#define EXTI_FTSR1_FT21 EXTI_FTSR1_FT21_Msk /*!< Falling trigger event configuration bit of line 21 */ + +/****************** Bit definition for EXTI_SWIER1 register *****************/ +#define EXTI_SWIER1_SWI0_Pos (0U) +#define EXTI_SWIER1_SWI0_Msk (0x1UL << EXTI_SWIER1_SWI0_Pos) /*!< 0x00000001 */ +#define EXTI_SWIER1_SWI0 EXTI_SWIER1_SWI0_Msk /*!< Software Interrupt on line 0 */ +#define EXTI_SWIER1_SWI1_Pos (1U) +#define EXTI_SWIER1_SWI1_Msk (0x1UL << EXTI_SWIER1_SWI1_Pos) /*!< 0x00000002 */ +#define EXTI_SWIER1_SWI1 EXTI_SWIER1_SWI1_Msk /*!< Software Interrupt on line 1 */ +#define EXTI_SWIER1_SWI2_Pos (2U) +#define EXTI_SWIER1_SWI2_Msk (0x1UL << EXTI_SWIER1_SWI2_Pos) /*!< 0x00000004 */ +#define EXTI_SWIER1_SWI2 EXTI_SWIER1_SWI2_Msk /*!< Software Interrupt on line 2 */ +#define EXTI_SWIER1_SWI3_Pos (3U) +#define EXTI_SWIER1_SWI3_Msk (0x1UL << EXTI_SWIER1_SWI3_Pos) /*!< 0x00000008 */ +#define EXTI_SWIER1_SWI3 EXTI_SWIER1_SWI3_Msk /*!< Software Interrupt on line 3 */ +#define EXTI_SWIER1_SWI4_Pos (4U) +#define EXTI_SWIER1_SWI4_Msk (0x1UL << EXTI_SWIER1_SWI4_Pos) /*!< 0x00000010 */ +#define EXTI_SWIER1_SWI4 EXTI_SWIER1_SWI4_Msk /*!< Software Interrupt on line 4 */ +#define EXTI_SWIER1_SWI5_Pos (5U) +#define EXTI_SWIER1_SWI5_Msk (0x1UL << EXTI_SWIER1_SWI5_Pos) /*!< 0x00000020 */ +#define EXTI_SWIER1_SWI5 EXTI_SWIER1_SWI5_Msk /*!< Software Interrupt on line 5 */ +#define EXTI_SWIER1_SWI6_Pos (6U) +#define EXTI_SWIER1_SWI6_Msk (0x1UL << EXTI_SWIER1_SWI6_Pos) /*!< 0x00000040 */ +#define EXTI_SWIER1_SWI6 EXTI_SWIER1_SWI6_Msk /*!< Software Interrupt on line 6 */ +#define EXTI_SWIER1_SWI7_Pos (7U) +#define EXTI_SWIER1_SWI7_Msk (0x1UL << EXTI_SWIER1_SWI7_Pos) /*!< 0x00000080 */ +#define EXTI_SWIER1_SWI7 EXTI_SWIER1_SWI7_Msk /*!< Software Interrupt on line 7 */ +#define EXTI_SWIER1_SWI8_Pos (8U) +#define EXTI_SWIER1_SWI8_Msk (0x1UL << EXTI_SWIER1_SWI8_Pos) /*!< 0x00000100 */ +#define EXTI_SWIER1_SWI8 EXTI_SWIER1_SWI8_Msk /*!< Software Interrupt on line 8 */ +#define EXTI_SWIER1_SWI9_Pos (9U) +#define EXTI_SWIER1_SWI9_Msk (0x1UL << EXTI_SWIER1_SWI9_Pos) /*!< 0x00000200 */ +#define EXTI_SWIER1_SWI9 EXTI_SWIER1_SWI9_Msk /*!< Software Interrupt on line 9 */ +#define EXTI_SWIER1_SWI10_Pos (10U) +#define EXTI_SWIER1_SWI10_Msk (0x1UL << EXTI_SWIER1_SWI10_Pos) /*!< 0x00000400 */ +#define EXTI_SWIER1_SWI10 EXTI_SWIER1_SWI10_Msk /*!< Software Interrupt on line 10 */ +#define EXTI_SWIER1_SWI11_Pos (11U) +#define EXTI_SWIER1_SWI11_Msk (0x1UL << EXTI_SWIER1_SWI11_Pos) /*!< 0x00000800 */ +#define EXTI_SWIER1_SWI11 EXTI_SWIER1_SWI11_Msk /*!< Software Interrupt on line 11 */ +#define EXTI_SWIER1_SWI12_Pos (12U) +#define EXTI_SWIER1_SWI12_Msk (0x1UL << EXTI_SWIER1_SWI12_Pos) /*!< 0x00001000 */ +#define EXTI_SWIER1_SWI12 EXTI_SWIER1_SWI12_Msk /*!< Software Interrupt on line 12 */ +#define EXTI_SWIER1_SWI13_Pos (13U) +#define EXTI_SWIER1_SWI13_Msk (0x1UL << EXTI_SWIER1_SWI13_Pos) /*!< 0x00002000 */ +#define EXTI_SWIER1_SWI13 EXTI_SWIER1_SWI13_Msk /*!< Software Interrupt on line 13 */ +#define EXTI_SWIER1_SWI14_Pos (14U) +#define EXTI_SWIER1_SWI14_Msk (0x1UL << EXTI_SWIER1_SWI14_Pos) /*!< 0x00004000 */ +#define EXTI_SWIER1_SWI14 EXTI_SWIER1_SWI14_Msk /*!< Software Interrupt on line 14 */ +#define EXTI_SWIER1_SWI15_Pos (15U) +#define EXTI_SWIER1_SWI15_Msk (0x1UL << EXTI_SWIER1_SWI15_Pos) /*!< 0x00008000 */ +#define EXTI_SWIER1_SWI15 EXTI_SWIER1_SWI15_Msk /*!< Software Interrupt on line 15 */ +#define EXTI_SWIER1_SWI16_Pos (16U) +#define EXTI_SWIER1_SWI16_Msk (0x1UL << EXTI_SWIER1_SWI16_Pos) /*!< 0x00010000 */ +#define EXTI_SWIER1_SWI16 EXTI_SWIER1_SWI16_Msk /*!< Software Interrupt on line 16 */ +#define EXTI_SWIER1_SWI18_Pos (18U) +#define EXTI_SWIER1_SWI18_Msk (0x1UL << EXTI_SWIER1_SWI18_Pos) /*!< 0x00040000 */ +#define EXTI_SWIER1_SWI18 EXTI_SWIER1_SWI18_Msk /*!< Software Interrupt on line 18 */ +#define EXTI_SWIER1_SWI19_Pos (19U) +#define EXTI_SWIER1_SWI19_Msk (0x1UL << EXTI_SWIER1_SWI19_Pos) /*!< 0x00080000 */ +#define EXTI_SWIER1_SWI19 EXTI_SWIER1_SWI19_Msk /*!< Software Interrupt on line 19 */ +#define EXTI_SWIER1_SWI20_Pos (20U) +#define EXTI_SWIER1_SWI20_Msk (0x1UL << EXTI_SWIER1_SWI20_Pos) /*!< 0x00100000 */ +#define EXTI_SWIER1_SWI20 EXTI_SWIER1_SWI20_Msk /*!< Software Interrupt on line 20 */ +#define EXTI_SWIER1_SWI21_Pos (21U) +#define EXTI_SWIER1_SWI21_Msk (0x1UL << EXTI_SWIER1_SWI21_Pos) /*!< 0x00200000 */ +#define EXTI_SWIER1_SWI21 EXTI_SWIER1_SWI21_Msk /*!< Software Interrupt on line 21 */ + +/******************* Bit definition for EXTI_PR1 register *******************/ +#define EXTI_PR1_PIF0_Pos (0U) +#define EXTI_PR1_PIF0_Msk (0x1UL << EXTI_PR1_PIF0_Pos) /*!< 0x00000001 */ +#define EXTI_PR1_PIF0 EXTI_PR1_PIF0_Msk /*!< Pending bit for line 0 */ +#define EXTI_PR1_PIF1_Pos (1U) +#define EXTI_PR1_PIF1_Msk (0x1UL << EXTI_PR1_PIF1_Pos) /*!< 0x00000002 */ +#define EXTI_PR1_PIF1 EXTI_PR1_PIF1_Msk /*!< Pending bit for line 1 */ +#define EXTI_PR1_PIF2_Pos (2U) +#define EXTI_PR1_PIF2_Msk (0x1UL << EXTI_PR1_PIF2_Pos) /*!< 0x00000004 */ +#define EXTI_PR1_PIF2 EXTI_PR1_PIF2_Msk /*!< Pending bit for line 2 */ +#define EXTI_PR1_PIF3_Pos (3U) +#define EXTI_PR1_PIF3_Msk (0x1UL << EXTI_PR1_PIF3_Pos) /*!< 0x00000008 */ +#define EXTI_PR1_PIF3 EXTI_PR1_PIF3_Msk /*!< Pending bit for line 3 */ +#define EXTI_PR1_PIF4_Pos (4U) +#define EXTI_PR1_PIF4_Msk (0x1UL << EXTI_PR1_PIF4_Pos) /*!< 0x00000010 */ +#define EXTI_PR1_PIF4 EXTI_PR1_PIF4_Msk /*!< Pending bit for line 4 */ +#define EXTI_PR1_PIF5_Pos (5U) +#define EXTI_PR1_PIF5_Msk (0x1UL << EXTI_PR1_PIF5_Pos) /*!< 0x00000020 */ +#define EXTI_PR1_PIF5 EXTI_PR1_PIF5_Msk /*!< Pending bit for line 5 */ +#define EXTI_PR1_PIF6_Pos (6U) +#define EXTI_PR1_PIF6_Msk (0x1UL << EXTI_PR1_PIF6_Pos) /*!< 0x00000040 */ +#define EXTI_PR1_PIF6 EXTI_PR1_PIF6_Msk /*!< Pending bit for line 6 */ +#define EXTI_PR1_PIF7_Pos (7U) +#define EXTI_PR1_PIF7_Msk (0x1UL << EXTI_PR1_PIF7_Pos) /*!< 0x00000080 */ +#define EXTI_PR1_PIF7 EXTI_PR1_PIF7_Msk /*!< Pending bit for line 7 */ +#define EXTI_PR1_PIF8_Pos (8U) +#define EXTI_PR1_PIF8_Msk (0x1UL << EXTI_PR1_PIF8_Pos) /*!< 0x00000100 */ +#define EXTI_PR1_PIF8 EXTI_PR1_PIF8_Msk /*!< Pending bit for line 8 */ +#define EXTI_PR1_PIF9_Pos (9U) +#define EXTI_PR1_PIF9_Msk (0x1UL << EXTI_PR1_PIF9_Pos) /*!< 0x00000200 */ +#define EXTI_PR1_PIF9 EXTI_PR1_PIF9_Msk /*!< Pending bit for line 9 */ +#define EXTI_PR1_PIF10_Pos (10U) +#define EXTI_PR1_PIF10_Msk (0x1UL << EXTI_PR1_PIF10_Pos) /*!< 0x00000400 */ +#define EXTI_PR1_PIF10 EXTI_PR1_PIF10_Msk /*!< Pending bit for line 10 */ +#define EXTI_PR1_PIF11_Pos (11U) +#define EXTI_PR1_PIF11_Msk (0x1UL << EXTI_PR1_PIF11_Pos) /*!< 0x00000800 */ +#define EXTI_PR1_PIF11 EXTI_PR1_PIF11_Msk /*!< Pending bit for line 11 */ +#define EXTI_PR1_PIF12_Pos (12U) +#define EXTI_PR1_PIF12_Msk (0x1UL << EXTI_PR1_PIF12_Pos) /*!< 0x00001000 */ +#define EXTI_PR1_PIF12 EXTI_PR1_PIF12_Msk /*!< Pending bit for line 12 */ +#define EXTI_PR1_PIF13_Pos (13U) +#define EXTI_PR1_PIF13_Msk (0x1UL << EXTI_PR1_PIF13_Pos) /*!< 0x00002000 */ +#define EXTI_PR1_PIF13 EXTI_PR1_PIF13_Msk /*!< Pending bit for line 13 */ +#define EXTI_PR1_PIF14_Pos (14U) +#define EXTI_PR1_PIF14_Msk (0x1UL << EXTI_PR1_PIF14_Pos) /*!< 0x00004000 */ +#define EXTI_PR1_PIF14 EXTI_PR1_PIF14_Msk /*!< Pending bit for line 14 */ +#define EXTI_PR1_PIF15_Pos (15U) +#define EXTI_PR1_PIF15_Msk (0x1UL << EXTI_PR1_PIF15_Pos) /*!< 0x00008000 */ +#define EXTI_PR1_PIF15 EXTI_PR1_PIF15_Msk /*!< Pending bit for line 15 */ +#define EXTI_PR1_PIF16_Pos (16U) +#define EXTI_PR1_PIF16_Msk (0x1UL << EXTI_PR1_PIF16_Pos) /*!< 0x00010000 */ +#define EXTI_PR1_PIF16 EXTI_PR1_PIF16_Msk /*!< Pending bit for line 16 */ +#define EXTI_PR1_PIF18_Pos (18U) +#define EXTI_PR1_PIF18_Msk (0x1UL << EXTI_PR1_PIF18_Pos) /*!< 0x00040000 */ +#define EXTI_PR1_PIF18 EXTI_PR1_PIF18_Msk /*!< Pending bit for line 18 */ +#define EXTI_PR1_PIF19_Pos (19U) +#define EXTI_PR1_PIF19_Msk (0x1UL << EXTI_PR1_PIF19_Pos) /*!< 0x00080000 */ +#define EXTI_PR1_PIF19 EXTI_PR1_PIF19_Msk /*!< Pending bit for line 19 */ +#define EXTI_PR1_PIF20_Pos (20U) +#define EXTI_PR1_PIF20_Msk (0x1UL << EXTI_PR1_PIF20_Pos) /*!< 0x00100000 */ +#define EXTI_PR1_PIF20 EXTI_PR1_PIF20_Msk /*!< Pending bit for line 20 */ +#define EXTI_PR1_PIF21_Pos (21U) +#define EXTI_PR1_PIF21_Msk (0x1UL << EXTI_PR1_PIF21_Pos) /*!< 0x00200000 */ +#define EXTI_PR1_PIF21 EXTI_PR1_PIF21_Msk /*!< Pending bit for line 21 */ + +/******************* Bit definition for EXTI_IMR2 register ******************/ +#define EXTI_IMR2_IM32_Pos (0U) +#define EXTI_IMR2_IM32_Msk (0x1UL << EXTI_IMR2_IM32_Pos) /*!< 0x00000001 */ +#define EXTI_IMR2_IM32 EXTI_IMR2_IM32_Msk /*!< Interrupt Mask on line 32 */ +#define EXTI_IMR2_IM33_Pos (1U) +#define EXTI_IMR2_IM33_Msk (0x1UL << EXTI_IMR2_IM33_Pos) /*!< 0x00000002 */ +#define EXTI_IMR2_IM33 EXTI_IMR2_IM33_Msk /*!< Interrupt Mask on line 33 */ +#define EXTI_IMR2_IM35_Pos (3U) +#define EXTI_IMR2_IM35_Msk (0x1UL << EXTI_IMR2_IM35_Pos) /*!< 0x00000008 */ +#define EXTI_IMR2_IM35 EXTI_IMR2_IM35_Msk /*!< Interrupt Mask on line 35 */ +#define EXTI_IMR2_IM37_Pos (5U) +#define EXTI_IMR2_IM37_Msk (0x1UL << EXTI_IMR2_IM37_Pos) /*!< 0x00000020 */ +#define EXTI_IMR2_IM37 EXTI_IMR2_IM37_Msk /*!< Interrupt Mask on line 37 */ +#define EXTI_IMR2_IM38_Pos (6U) +#define EXTI_IMR2_IM38_Msk (0x1UL << EXTI_IMR2_IM38_Pos) /*!< 0x00000040 */ +#define EXTI_IMR2_IM38 EXTI_IMR2_IM38_Msk /*!< Interrupt Mask on line 38 */ +#define EXTI_IMR2_IM_Pos (0U) +#define EXTI_IMR2_IM_Msk (0x6BUL << EXTI_IMR2_IM_Pos) /*!< 0x0000006B */ +#define EXTI_IMR2_IM EXTI_IMR2_IM_Msk /*!< Interrupt Mask all */ + +/******************* Bit definition for EXTI_EMR2 register ******************/ +#define EXTI_EMR2_EM32_Pos (0U) +#define EXTI_EMR2_EM32_Msk (0x1UL << EXTI_EMR2_EM32_Pos) /*!< 0x00000001 */ +#define EXTI_EMR2_EM32 EXTI_EMR2_EM32_Msk /*!< Event Mask on line 32 */ +#define EXTI_EMR2_EM33_Pos (1U) +#define EXTI_EMR2_EM33_Msk (0x1UL << EXTI_EMR2_EM33_Pos) /*!< 0x00000002 */ +#define EXTI_EMR2_EM33 EXTI_EMR2_EM33_Msk /*!< Event Mask on line 33 */ +#define EXTI_EMR2_EM35_Pos (3U) +#define EXTI_EMR2_EM35_Msk (0x1UL << EXTI_EMR2_EM35_Pos) /*!< 0x00000008 */ +#define EXTI_EMR2_EM35 EXTI_EMR2_EM35_Msk /*!< Event Mask on line 35 */ +#define EXTI_EMR2_EM37_Pos (5U) +#define EXTI_EMR2_EM37_Msk (0x1UL << EXTI_EMR2_EM37_Pos) /*!< 0x00000020 */ +#define EXTI_EMR2_EM37 EXTI_EMR2_EM37_Msk /*!< Event Mask on line 37 */ +#define EXTI_EMR2_EM38_Pos (6U) +#define EXTI_EMR2_EM38_Msk (0x1UL << EXTI_EMR2_EM38_Pos) /*!< 0x00000040 */ +#define EXTI_EMR2_EM38 EXTI_EMR2_EM38_Msk /*!< Event Mask on line 38 */ +#define EXTI_EMR2_EM_Pos (0U) +#define EXTI_EMR2_EM_Msk (0x6BUL << EXTI_EMR2_EM_Pos) /*!< 0x0000006B */ +#define EXTI_EMR2_EM EXTI_EMR2_EM_Msk /*!< Interrupt Mask all */ + +/****************** Bit definition for EXTI_RTSR2 register ******************/ +#define EXTI_RTSR2_RT35_Pos (3U) +#define EXTI_RTSR2_RT35_Msk (0x1UL << EXTI_RTSR2_RT35_Pos) /*!< 0x00000008 */ +#define EXTI_RTSR2_RT35 EXTI_RTSR2_RT35_Msk /*!< Rising trigger event configuration bit of line 35 */ +#define EXTI_RTSR2_RT37_Pos (5U) +#define EXTI_RTSR2_RT37_Msk (0x1UL << EXTI_RTSR2_RT37_Pos) /*!< 0x00000020 */ +#define EXTI_RTSR2_RT37 EXTI_RTSR2_RT37_Msk /*!< Rising trigger event configuration bit of line 37 */ +#define EXTI_RTSR2_RT38_Pos (6U) +#define EXTI_RTSR2_RT38_Msk (0x1UL << EXTI_RTSR2_RT38_Pos) /*!< 0x00000040 */ +#define EXTI_RTSR2_RT38 EXTI_RTSR2_RT38_Msk /*!< Rising trigger event configuration bit of line 38 */ + +/****************** Bit definition for EXTI_FTSR2 register ******************/ +#define EXTI_FTSR2_FT35_Pos (3U) +#define EXTI_FTSR2_FT35_Msk (0x1UL << EXTI_FTSR2_FT35_Pos) /*!< 0x00000008 */ +#define EXTI_FTSR2_FT35 EXTI_FTSR2_FT35_Msk /*!< Falling trigger event configuration bit of line 35 */ +#define EXTI_FTSR2_FT37_Pos (5U) +#define EXTI_FTSR2_FT37_Msk (0x1UL << EXTI_FTSR2_FT37_Pos) /*!< 0x00000020 */ +#define EXTI_FTSR2_FT37 EXTI_FTSR2_FT37_Msk /*!< Falling trigger event configuration bit of line 37 */ +#define EXTI_FTSR2_FT38_Pos (6U) +#define EXTI_FTSR2_FT38_Msk (0x1UL << EXTI_FTSR2_FT38_Pos) /*!< 0x00000040 */ +#define EXTI_FTSR2_FT38 EXTI_FTSR2_FT38_Msk /*!< Falling trigger event configuration bit of line 38 */ + +/****************** Bit definition for EXTI_SWIER2 register *****************/ +#define EXTI_SWIER2_SWI35_Pos (3U) +#define EXTI_SWIER2_SWI35_Msk (0x1UL << EXTI_SWIER2_SWI35_Pos) /*!< 0x00000008 */ +#define EXTI_SWIER2_SWI35 EXTI_SWIER2_SWI35_Msk /*!< Software Interrupt on line 35 */ +#define EXTI_SWIER2_SWI37_Pos (5U) +#define EXTI_SWIER2_SWI37_Msk (0x1UL << EXTI_SWIER2_SWI37_Pos) /*!< 0x00000020 */ +#define EXTI_SWIER2_SWI37 EXTI_SWIER2_SWI37_Msk /*!< Software Interrupt on line 37 */ +#define EXTI_SWIER2_SWI38_Pos (6U) +#define EXTI_SWIER2_SWI38_Msk (0x1UL << EXTI_SWIER2_SWI38_Pos) /*!< 0x00000040 */ +#define EXTI_SWIER2_SWI38 EXTI_SWIER2_SWI38_Msk /*!< Software Interrupt on line 38 */ + +/******************* Bit definition for EXTI_PR2 register *******************/ +#define EXTI_PR2_PIF35_Pos (3U) +#define EXTI_PR2_PIF35_Msk (0x1UL << EXTI_PR2_PIF35_Pos) /*!< 0x00000008 */ +#define EXTI_PR2_PIF35 EXTI_PR2_PIF35_Msk /*!< Pending bit for line 35 */ +#define EXTI_PR2_PIF37_Pos (5U) +#define EXTI_PR2_PIF37_Msk (0x1UL << EXTI_PR2_PIF37_Pos) /*!< 0x00000020 */ +#define EXTI_PR2_PIF37 EXTI_PR2_PIF37_Msk /*!< Pending bit for line 37 */ +#define EXTI_PR2_PIF38_Pos (6U) +#define EXTI_PR2_PIF38_Msk (0x1UL << EXTI_PR2_PIF38_Pos) /*!< 0x00000040 */ +#define EXTI_PR2_PIF38 EXTI_PR2_PIF38_Msk /*!< Pending bit for line 38 */ + + +/******************************************************************************/ +/* */ +/* FLASH */ +/* */ +/******************************************************************************/ +/******************* Bits definition for FLASH_ACR register *****************/ +#define FLASH_ACR_LATENCY_Pos (0U) +#define FLASH_ACR_LATENCY_Msk (0x7UL << FLASH_ACR_LATENCY_Pos) /*!< 0x00000007 */ +#define FLASH_ACR_LATENCY FLASH_ACR_LATENCY_Msk +#define FLASH_ACR_LATENCY_0WS (0x00000000UL) +#define FLASH_ACR_LATENCY_1WS (0x00000001UL) +#define FLASH_ACR_LATENCY_2WS (0x00000002UL) +#define FLASH_ACR_LATENCY_3WS (0x00000003UL) +#define FLASH_ACR_LATENCY_4WS (0x00000004UL) +#define FLASH_ACR_PRFTEN_Pos (8U) +#define FLASH_ACR_PRFTEN_Msk (0x1UL << FLASH_ACR_PRFTEN_Pos) /*!< 0x00000100 */ +#define FLASH_ACR_PRFTEN FLASH_ACR_PRFTEN_Msk +#define FLASH_ACR_ICEN_Pos (9U) +#define FLASH_ACR_ICEN_Msk (0x1UL << FLASH_ACR_ICEN_Pos) /*!< 0x00000200 */ +#define FLASH_ACR_ICEN FLASH_ACR_ICEN_Msk +#define FLASH_ACR_DCEN_Pos (10U) +#define FLASH_ACR_DCEN_Msk (0x1UL << FLASH_ACR_DCEN_Pos) /*!< 0x00000400 */ +#define FLASH_ACR_DCEN FLASH_ACR_DCEN_Msk +#define FLASH_ACR_ICRST_Pos (11U) +#define FLASH_ACR_ICRST_Msk (0x1UL << FLASH_ACR_ICRST_Pos) /*!< 0x00000800 */ +#define FLASH_ACR_ICRST FLASH_ACR_ICRST_Msk +#define FLASH_ACR_DCRST_Pos (12U) +#define FLASH_ACR_DCRST_Msk (0x1UL << FLASH_ACR_DCRST_Pos) /*!< 0x00001000 */ +#define FLASH_ACR_DCRST FLASH_ACR_DCRST_Msk +#define FLASH_ACR_RUN_PD_Pos (13U) +#define FLASH_ACR_RUN_PD_Msk (0x1UL << FLASH_ACR_RUN_PD_Pos) /*!< 0x00002000 */ +#define FLASH_ACR_RUN_PD FLASH_ACR_RUN_PD_Msk /*!< Flash power down mode during run */ +#define FLASH_ACR_SLEEP_PD_Pos (14U) +#define FLASH_ACR_SLEEP_PD_Msk (0x1UL << FLASH_ACR_SLEEP_PD_Pos) /*!< 0x00004000 */ +#define FLASH_ACR_SLEEP_PD FLASH_ACR_SLEEP_PD_Msk /*!< Flash power down mode during sleep */ + +/******************* Bits definition for FLASH_SR register ******************/ +#define FLASH_SR_EOP_Pos (0U) +#define FLASH_SR_EOP_Msk (0x1UL << FLASH_SR_EOP_Pos) /*!< 0x00000001 */ +#define FLASH_SR_EOP FLASH_SR_EOP_Msk +#define FLASH_SR_OPERR_Pos (1U) +#define FLASH_SR_OPERR_Msk (0x1UL << FLASH_SR_OPERR_Pos) /*!< 0x00000002 */ +#define FLASH_SR_OPERR FLASH_SR_OPERR_Msk +#define FLASH_SR_PROGERR_Pos (3U) +#define FLASH_SR_PROGERR_Msk (0x1UL << FLASH_SR_PROGERR_Pos) /*!< 0x00000008 */ +#define FLASH_SR_PROGERR FLASH_SR_PROGERR_Msk +#define FLASH_SR_WRPERR_Pos (4U) +#define FLASH_SR_WRPERR_Msk (0x1UL << FLASH_SR_WRPERR_Pos) /*!< 0x00000010 */ +#define FLASH_SR_WRPERR FLASH_SR_WRPERR_Msk +#define FLASH_SR_PGAERR_Pos (5U) +#define FLASH_SR_PGAERR_Msk (0x1UL << FLASH_SR_PGAERR_Pos) /*!< 0x00000020 */ +#define FLASH_SR_PGAERR FLASH_SR_PGAERR_Msk +#define FLASH_SR_SIZERR_Pos (6U) +#define FLASH_SR_SIZERR_Msk (0x1UL << FLASH_SR_SIZERR_Pos) /*!< 0x00000040 */ +#define FLASH_SR_SIZERR FLASH_SR_SIZERR_Msk +#define FLASH_SR_PGSERR_Pos (7U) +#define FLASH_SR_PGSERR_Msk (0x1UL << FLASH_SR_PGSERR_Pos) /*!< 0x00000080 */ +#define FLASH_SR_PGSERR FLASH_SR_PGSERR_Msk +#define FLASH_SR_MISERR_Pos (8U) +#define FLASH_SR_MISERR_Msk (0x1UL << FLASH_SR_MISERR_Pos) /*!< 0x00000100 */ +#define FLASH_SR_MISERR FLASH_SR_MISERR_Msk +#define FLASH_SR_FASTERR_Pos (9U) +#define FLASH_SR_FASTERR_Msk (0x1UL << FLASH_SR_FASTERR_Pos) /*!< 0x00000200 */ +#define FLASH_SR_FASTERR FLASH_SR_FASTERR_Msk +#define FLASH_SR_RDERR_Pos (14U) +#define FLASH_SR_RDERR_Msk (0x1UL << FLASH_SR_RDERR_Pos) /*!< 0x00004000 */ +#define FLASH_SR_RDERR FLASH_SR_RDERR_Msk +#define FLASH_SR_OPTVERR_Pos (15U) +#define FLASH_SR_OPTVERR_Msk (0x1UL << FLASH_SR_OPTVERR_Pos) /*!< 0x00008000 */ +#define FLASH_SR_OPTVERR FLASH_SR_OPTVERR_Msk +#define FLASH_SR_BSY_Pos (16U) +#define FLASH_SR_BSY_Msk (0x1UL << FLASH_SR_BSY_Pos) /*!< 0x00010000 */ +#define FLASH_SR_BSY FLASH_SR_BSY_Msk +#define FLASH_SR_PEMPTY_Pos (17U) +#define FLASH_SR_PEMPTY_Msk (0x1UL << FLASH_SR_PEMPTY_Pos) /*!< 0x00020000 */ +#define FLASH_SR_PEMPTY FLASH_SR_PEMPTY_Msk + +/******************* Bits definition for FLASH_CR register ******************/ +#define FLASH_CR_PG_Pos (0U) +#define FLASH_CR_PG_Msk (0x1UL << FLASH_CR_PG_Pos) /*!< 0x00000001 */ +#define FLASH_CR_PG FLASH_CR_PG_Msk +#define FLASH_CR_PER_Pos (1U) +#define FLASH_CR_PER_Msk (0x1UL << FLASH_CR_PER_Pos) /*!< 0x00000002 */ +#define FLASH_CR_PER FLASH_CR_PER_Msk +#define FLASH_CR_MER1_Pos (2U) +#define FLASH_CR_MER1_Msk (0x1UL << FLASH_CR_MER1_Pos) /*!< 0x00000004 */ +#define FLASH_CR_MER1 FLASH_CR_MER1_Msk +#define FLASH_CR_PNB_Pos (3U) +#define FLASH_CR_PNB_Msk (0x3FUL << FLASH_CR_PNB_Pos) /*!< 0x000001F8 */ +#define FLASH_CR_PNB FLASH_CR_PNB_Msk +#define FLASH_CR_STRT_Pos (16U) +#define FLASH_CR_STRT_Msk (0x1UL << FLASH_CR_STRT_Pos) /*!< 0x00010000 */ +#define FLASH_CR_STRT FLASH_CR_STRT_Msk +#define FLASH_CR_OPTSTRT_Pos (17U) +#define FLASH_CR_OPTSTRT_Msk (0x1UL << FLASH_CR_OPTSTRT_Pos) /*!< 0x00020000 */ +#define FLASH_CR_OPTSTRT FLASH_CR_OPTSTRT_Msk +#define FLASH_CR_FSTPG_Pos (18U) +#define FLASH_CR_FSTPG_Msk (0x1UL << FLASH_CR_FSTPG_Pos) /*!< 0x00040000 */ +#define FLASH_CR_FSTPG FLASH_CR_FSTPG_Msk +#define FLASH_CR_EOPIE_Pos (24U) +#define FLASH_CR_EOPIE_Msk (0x1UL << FLASH_CR_EOPIE_Pos) /*!< 0x01000000 */ +#define FLASH_CR_EOPIE FLASH_CR_EOPIE_Msk +#define FLASH_CR_ERRIE_Pos (25U) +#define FLASH_CR_ERRIE_Msk (0x1UL << FLASH_CR_ERRIE_Pos) /*!< 0x02000000 */ +#define FLASH_CR_ERRIE FLASH_CR_ERRIE_Msk +#define FLASH_CR_RDERRIE_Pos (26U) +#define FLASH_CR_RDERRIE_Msk (0x1UL << FLASH_CR_RDERRIE_Pos) /*!< 0x04000000 */ +#define FLASH_CR_RDERRIE FLASH_CR_RDERRIE_Msk +#define FLASH_CR_OBL_LAUNCH_Pos (27U) +#define FLASH_CR_OBL_LAUNCH_Msk (0x1UL << FLASH_CR_OBL_LAUNCH_Pos) /*!< 0x08000000 */ +#define FLASH_CR_OBL_LAUNCH FLASH_CR_OBL_LAUNCH_Msk +#define FLASH_CR_OPTLOCK_Pos (30U) +#define FLASH_CR_OPTLOCK_Msk (0x1UL << FLASH_CR_OPTLOCK_Pos) /*!< 0x40000000 */ +#define FLASH_CR_OPTLOCK FLASH_CR_OPTLOCK_Msk +#define FLASH_CR_LOCK_Pos (31U) +#define FLASH_CR_LOCK_Msk (0x1UL << FLASH_CR_LOCK_Pos) /*!< 0x80000000 */ +#define FLASH_CR_LOCK FLASH_CR_LOCK_Msk + +/******************* Bits definition for FLASH_ECCR register ***************/ +#define FLASH_ECCR_ADDR_ECC_Pos (0U) +#define FLASH_ECCR_ADDR_ECC_Msk (0x7FFFFUL << FLASH_ECCR_ADDR_ECC_Pos) /*!< 0x0007FFFF */ +#define FLASH_ECCR_ADDR_ECC FLASH_ECCR_ADDR_ECC_Msk +#define FLASH_ECCR_SYSF_ECC_Pos (20U) +#define FLASH_ECCR_SYSF_ECC_Msk (0x1UL << FLASH_ECCR_SYSF_ECC_Pos) /*!< 0x00100000 */ +#define FLASH_ECCR_SYSF_ECC FLASH_ECCR_SYSF_ECC_Msk +#define FLASH_ECCR_ECCIE_Pos (24U) +#define FLASH_ECCR_ECCIE_Msk (0x1UL << FLASH_ECCR_ECCIE_Pos) /*!< 0x01000000 */ +#define FLASH_ECCR_ECCIE FLASH_ECCR_ECCIE_Msk +#define FLASH_ECCR_ECCC_Pos (30U) +#define FLASH_ECCR_ECCC_Msk (0x1UL << FLASH_ECCR_ECCC_Pos) /*!< 0x40000000 */ +#define FLASH_ECCR_ECCC FLASH_ECCR_ECCC_Msk +#define FLASH_ECCR_ECCD_Pos (31U) +#define FLASH_ECCR_ECCD_Msk (0x1UL << FLASH_ECCR_ECCD_Pos) /*!< 0x80000000 */ +#define FLASH_ECCR_ECCD FLASH_ECCR_ECCD_Msk + +/******************* Bits definition for FLASH_OPTR register ***************/ +#define FLASH_OPTR_RDP_Pos (0U) +#define FLASH_OPTR_RDP_Msk (0xFFUL << FLASH_OPTR_RDP_Pos) /*!< 0x000000FF */ +#define FLASH_OPTR_RDP FLASH_OPTR_RDP_Msk +#define FLASH_OPTR_BOR_LEV_Pos (8U) +#define FLASH_OPTR_BOR_LEV_Msk (0x7UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000700 */ +#define FLASH_OPTR_BOR_LEV FLASH_OPTR_BOR_LEV_Msk +#define FLASH_OPTR_BOR_LEV_0 (0x0UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000000 */ +#define FLASH_OPTR_BOR_LEV_1 (0x1UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000100 */ +#define FLASH_OPTR_BOR_LEV_2 (0x2UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000200 */ +#define FLASH_OPTR_BOR_LEV_3 (0x3UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000300 */ +#define FLASH_OPTR_BOR_LEV_4 (0x4UL << FLASH_OPTR_BOR_LEV_Pos) /*!< 0x00000400 */ +#define FLASH_OPTR_nRST_STOP_Pos (12U) +#define FLASH_OPTR_nRST_STOP_Msk (0x1UL << FLASH_OPTR_nRST_STOP_Pos) /*!< 0x00001000 */ +#define FLASH_OPTR_nRST_STOP FLASH_OPTR_nRST_STOP_Msk +#define FLASH_OPTR_nRST_STDBY_Pos (13U) +#define FLASH_OPTR_nRST_STDBY_Msk (0x1UL << FLASH_OPTR_nRST_STDBY_Pos) /*!< 0x00002000 */ +#define FLASH_OPTR_nRST_STDBY FLASH_OPTR_nRST_STDBY_Msk +#define FLASH_OPTR_nRST_SHDW_Pos (14U) +#define FLASH_OPTR_nRST_SHDW_Msk (0x1UL << FLASH_OPTR_nRST_SHDW_Pos) /*!< 0x00004000 */ +#define FLASH_OPTR_nRST_SHDW FLASH_OPTR_nRST_SHDW_Msk +#define FLASH_OPTR_IWDG_SW_Pos (16U) +#define FLASH_OPTR_IWDG_SW_Msk (0x1UL << FLASH_OPTR_IWDG_SW_Pos) /*!< 0x00010000 */ +#define FLASH_OPTR_IWDG_SW FLASH_OPTR_IWDG_SW_Msk +#define FLASH_OPTR_IWDG_STOP_Pos (17U) +#define FLASH_OPTR_IWDG_STOP_Msk (0x1UL << FLASH_OPTR_IWDG_STOP_Pos) /*!< 0x00020000 */ +#define FLASH_OPTR_IWDG_STOP FLASH_OPTR_IWDG_STOP_Msk +#define FLASH_OPTR_IWDG_STDBY_Pos (18U) +#define FLASH_OPTR_IWDG_STDBY_Msk (0x1UL << FLASH_OPTR_IWDG_STDBY_Pos) /*!< 0x00040000 */ +#define FLASH_OPTR_IWDG_STDBY FLASH_OPTR_IWDG_STDBY_Msk +#define FLASH_OPTR_WWDG_SW_Pos (19U) +#define FLASH_OPTR_WWDG_SW_Msk (0x1UL << FLASH_OPTR_WWDG_SW_Pos) /*!< 0x00080000 */ +#define FLASH_OPTR_WWDG_SW FLASH_OPTR_WWDG_SW_Msk +#define FLASH_OPTR_nBOOT1_Pos (23U) +#define FLASH_OPTR_nBOOT1_Msk (0x1UL << FLASH_OPTR_nBOOT1_Pos) /*!< 0x00800000 */ +#define FLASH_OPTR_nBOOT1 FLASH_OPTR_nBOOT1_Msk +#define FLASH_OPTR_SRAM2_PE_Pos (24U) +#define FLASH_OPTR_SRAM2_PE_Msk (0x1UL << FLASH_OPTR_SRAM2_PE_Pos) /*!< 0x01000000 */ +#define FLASH_OPTR_SRAM2_PE FLASH_OPTR_SRAM2_PE_Msk +#define FLASH_OPTR_SRAM2_RST_Pos (25U) +#define FLASH_OPTR_SRAM2_RST_Msk (0x1UL << FLASH_OPTR_SRAM2_RST_Pos) /*!< 0x02000000 */ +#define FLASH_OPTR_SRAM2_RST FLASH_OPTR_SRAM2_RST_Msk +#define FLASH_OPTR_nSWBOOT0_Pos (26U) +#define FLASH_OPTR_nSWBOOT0_Msk (0x1UL << FLASH_OPTR_nSWBOOT0_Pos) /*!< 0x04000000 */ +#define FLASH_OPTR_nSWBOOT0 FLASH_OPTR_nSWBOOT0_Msk +#define FLASH_OPTR_nBOOT0_Pos (27U) +#define FLASH_OPTR_nBOOT0_Msk (0x1UL << FLASH_OPTR_nBOOT0_Pos) /*!< 0x08000000 */ +#define FLASH_OPTR_nBOOT0 FLASH_OPTR_nBOOT0_Msk + +/****************** Bits definition for FLASH_PCROP1SR register **********/ +#define FLASH_PCROP1SR_PCROP1_STRT_Pos (0U) +#define FLASH_PCROP1SR_PCROP1_STRT_Msk (0x3FFFUL << FLASH_PCROP1SR_PCROP1_STRT_Pos) /*!< 0x00003FFF */ +#define FLASH_PCROP1SR_PCROP1_STRT FLASH_PCROP1SR_PCROP1_STRT_Msk + +/****************** Bits definition for FLASH_PCROP1ER register ***********/ +#define FLASH_PCROP1ER_PCROP1_END_Pos (0U) +#define FLASH_PCROP1ER_PCROP1_END_Msk (0x3FFFUL << FLASH_PCROP1ER_PCROP1_END_Pos) /*!< 0x00003FFF */ +#define FLASH_PCROP1ER_PCROP1_END FLASH_PCROP1ER_PCROP1_END_Msk +#define FLASH_PCROP1ER_PCROP_RDP_Pos (31U) +#define FLASH_PCROP1ER_PCROP_RDP_Msk (0x1UL << FLASH_PCROP1ER_PCROP_RDP_Pos) /*!< 0x80000000 */ +#define FLASH_PCROP1ER_PCROP_RDP FLASH_PCROP1ER_PCROP_RDP_Msk + +/****************** Bits definition for FLASH_WRP1AR register ***************/ +#define FLASH_WRP1AR_WRP1A_STRT_Pos (0U) +#define FLASH_WRP1AR_WRP1A_STRT_Msk (0x3FUL << FLASH_WRP1AR_WRP1A_STRT_Pos) /*!< 0x0000003F */ +#define FLASH_WRP1AR_WRP1A_STRT FLASH_WRP1AR_WRP1A_STRT_Msk +#define FLASH_WRP1AR_WRP1A_END_Pos (16U) +#define FLASH_WRP1AR_WRP1A_END_Msk (0x3FUL << FLASH_WRP1AR_WRP1A_END_Pos) /*!< 0x003F0000 */ +#define FLASH_WRP1AR_WRP1A_END FLASH_WRP1AR_WRP1A_END_Msk + +/****************** Bits definition for FLASH_WRPB1R register ***************/ +#define FLASH_WRP1BR_WRP1B_STRT_Pos (0U) +#define FLASH_WRP1BR_WRP1B_STRT_Msk (0x3FUL << FLASH_WRP1BR_WRP1B_STRT_Pos) /*!< 0x0000003F */ +#define FLASH_WRP1BR_WRP1B_STRT FLASH_WRP1BR_WRP1B_STRT_Msk +#define FLASH_WRP1BR_WRP1B_END_Pos (16U) +#define FLASH_WRP1BR_WRP1B_END_Msk (0x3FUL << FLASH_WRP1BR_WRP1B_END_Pos) /*!< 0x003F0000 */ +#define FLASH_WRP1BR_WRP1B_END FLASH_WRP1BR_WRP1B_END_Msk + + + + +/******************************************************************************/ +/* */ +/* General Purpose IOs (GPIO) */ +/* */ +/******************************************************************************/ +/****************** Bits definition for GPIO_MODER register *****************/ +#define GPIO_MODER_MODE0_Pos (0U) +#define GPIO_MODER_MODE0_Msk (0x3UL << GPIO_MODER_MODE0_Pos) /*!< 0x00000003 */ +#define GPIO_MODER_MODE0 GPIO_MODER_MODE0_Msk +#define GPIO_MODER_MODE0_0 (0x1UL << GPIO_MODER_MODE0_Pos) /*!< 0x00000001 */ +#define GPIO_MODER_MODE0_1 (0x2UL << GPIO_MODER_MODE0_Pos) /*!< 0x00000002 */ +#define GPIO_MODER_MODE1_Pos (2U) +#define GPIO_MODER_MODE1_Msk (0x3UL << GPIO_MODER_MODE1_Pos) /*!< 0x0000000C */ +#define GPIO_MODER_MODE1 GPIO_MODER_MODE1_Msk +#define GPIO_MODER_MODE1_0 (0x1UL << GPIO_MODER_MODE1_Pos) /*!< 0x00000004 */ +#define GPIO_MODER_MODE1_1 (0x2UL << GPIO_MODER_MODE1_Pos) /*!< 0x00000008 */ +#define GPIO_MODER_MODE2_Pos (4U) +#define GPIO_MODER_MODE2_Msk (0x3UL << GPIO_MODER_MODE2_Pos) /*!< 0x00000030 */ +#define GPIO_MODER_MODE2 GPIO_MODER_MODE2_Msk +#define GPIO_MODER_MODE2_0 (0x1UL << GPIO_MODER_MODE2_Pos) /*!< 0x00000010 */ +#define GPIO_MODER_MODE2_1 (0x2UL << GPIO_MODER_MODE2_Pos) /*!< 0x00000020 */ +#define GPIO_MODER_MODE3_Pos (6U) +#define GPIO_MODER_MODE3_Msk (0x3UL << GPIO_MODER_MODE3_Pos) /*!< 0x000000C0 */ +#define GPIO_MODER_MODE3 GPIO_MODER_MODE3_Msk +#define GPIO_MODER_MODE3_0 (0x1UL << GPIO_MODER_MODE3_Pos) /*!< 0x00000040 */ +#define GPIO_MODER_MODE3_1 (0x2UL << GPIO_MODER_MODE3_Pos) /*!< 0x00000080 */ +#define GPIO_MODER_MODE4_Pos (8U) +#define GPIO_MODER_MODE4_Msk (0x3UL << GPIO_MODER_MODE4_Pos) /*!< 0x00000300 */ +#define GPIO_MODER_MODE4 GPIO_MODER_MODE4_Msk +#define GPIO_MODER_MODE4_0 (0x1UL << GPIO_MODER_MODE4_Pos) /*!< 0x00000100 */ +#define GPIO_MODER_MODE4_1 (0x2UL << GPIO_MODER_MODE4_Pos) /*!< 0x00000200 */ +#define GPIO_MODER_MODE5_Pos (10U) +#define GPIO_MODER_MODE5_Msk (0x3UL << GPIO_MODER_MODE5_Pos) /*!< 0x00000C00 */ +#define GPIO_MODER_MODE5 GPIO_MODER_MODE5_Msk +#define GPIO_MODER_MODE5_0 (0x1UL << GPIO_MODER_MODE5_Pos) /*!< 0x00000400 */ +#define GPIO_MODER_MODE5_1 (0x2UL << GPIO_MODER_MODE5_Pos) /*!< 0x00000800 */ +#define GPIO_MODER_MODE6_Pos (12U) +#define GPIO_MODER_MODE6_Msk (0x3UL << GPIO_MODER_MODE6_Pos) /*!< 0x00003000 */ +#define GPIO_MODER_MODE6 GPIO_MODER_MODE6_Msk +#define GPIO_MODER_MODE6_0 (0x1UL << GPIO_MODER_MODE6_Pos) /*!< 0x00001000 */ +#define GPIO_MODER_MODE6_1 (0x2UL << GPIO_MODER_MODE6_Pos) /*!< 0x00002000 */ +#define GPIO_MODER_MODE7_Pos (14U) +#define GPIO_MODER_MODE7_Msk (0x3UL << GPIO_MODER_MODE7_Pos) /*!< 0x0000C000 */ +#define GPIO_MODER_MODE7 GPIO_MODER_MODE7_Msk +#define GPIO_MODER_MODE7_0 (0x1UL << GPIO_MODER_MODE7_Pos) /*!< 0x00004000 */ +#define GPIO_MODER_MODE7_1 (0x2UL << GPIO_MODER_MODE7_Pos) /*!< 0x00008000 */ +#define GPIO_MODER_MODE8_Pos (16U) +#define GPIO_MODER_MODE8_Msk (0x3UL << GPIO_MODER_MODE8_Pos) /*!< 0x00030000 */ +#define GPIO_MODER_MODE8 GPIO_MODER_MODE8_Msk +#define GPIO_MODER_MODE8_0 (0x1UL << GPIO_MODER_MODE8_Pos) /*!< 0x00010000 */ +#define GPIO_MODER_MODE8_1 (0x2UL << GPIO_MODER_MODE8_Pos) /*!< 0x00020000 */ +#define GPIO_MODER_MODE9_Pos (18U) +#define GPIO_MODER_MODE9_Msk (0x3UL << GPIO_MODER_MODE9_Pos) /*!< 0x000C0000 */ +#define GPIO_MODER_MODE9 GPIO_MODER_MODE9_Msk +#define GPIO_MODER_MODE9_0 (0x1UL << GPIO_MODER_MODE9_Pos) /*!< 0x00040000 */ +#define GPIO_MODER_MODE9_1 (0x2UL << GPIO_MODER_MODE9_Pos) /*!< 0x00080000 */ +#define GPIO_MODER_MODE10_Pos (20U) +#define GPIO_MODER_MODE10_Msk (0x3UL << GPIO_MODER_MODE10_Pos) /*!< 0x00300000 */ +#define GPIO_MODER_MODE10 GPIO_MODER_MODE10_Msk +#define GPIO_MODER_MODE10_0 (0x1UL << GPIO_MODER_MODE10_Pos) /*!< 0x00100000 */ +#define GPIO_MODER_MODE10_1 (0x2UL << GPIO_MODER_MODE10_Pos) /*!< 0x00200000 */ +#define GPIO_MODER_MODE11_Pos (22U) +#define GPIO_MODER_MODE11_Msk (0x3UL << GPIO_MODER_MODE11_Pos) /*!< 0x00C00000 */ +#define GPIO_MODER_MODE11 GPIO_MODER_MODE11_Msk +#define GPIO_MODER_MODE11_0 (0x1UL << GPIO_MODER_MODE11_Pos) /*!< 0x00400000 */ +#define GPIO_MODER_MODE11_1 (0x2UL << GPIO_MODER_MODE11_Pos) /*!< 0x00800000 */ +#define GPIO_MODER_MODE12_Pos (24U) +#define GPIO_MODER_MODE12_Msk (0x3UL << GPIO_MODER_MODE12_Pos) /*!< 0x03000000 */ +#define GPIO_MODER_MODE12 GPIO_MODER_MODE12_Msk +#define GPIO_MODER_MODE12_0 (0x1UL << GPIO_MODER_MODE12_Pos) /*!< 0x01000000 */ +#define GPIO_MODER_MODE12_1 (0x2UL << GPIO_MODER_MODE12_Pos) /*!< 0x02000000 */ +#define GPIO_MODER_MODE13_Pos (26U) +#define GPIO_MODER_MODE13_Msk (0x3UL << GPIO_MODER_MODE13_Pos) /*!< 0x0C000000 */ +#define GPIO_MODER_MODE13 GPIO_MODER_MODE13_Msk +#define GPIO_MODER_MODE13_0 (0x1UL << GPIO_MODER_MODE13_Pos) /*!< 0x04000000 */ +#define GPIO_MODER_MODE13_1 (0x2UL << GPIO_MODER_MODE13_Pos) /*!< 0x08000000 */ +#define GPIO_MODER_MODE14_Pos (28U) +#define GPIO_MODER_MODE14_Msk (0x3UL << GPIO_MODER_MODE14_Pos) /*!< 0x30000000 */ +#define GPIO_MODER_MODE14 GPIO_MODER_MODE14_Msk +#define GPIO_MODER_MODE14_0 (0x1UL << GPIO_MODER_MODE14_Pos) /*!< 0x10000000 */ +#define GPIO_MODER_MODE14_1 (0x2UL << GPIO_MODER_MODE14_Pos) /*!< 0x20000000 */ +#define GPIO_MODER_MODE15_Pos (30U) +#define GPIO_MODER_MODE15_Msk (0x3UL << GPIO_MODER_MODE15_Pos) /*!< 0xC0000000 */ +#define GPIO_MODER_MODE15 GPIO_MODER_MODE15_Msk +#define GPIO_MODER_MODE15_0 (0x1UL << GPIO_MODER_MODE15_Pos) /*!< 0x40000000 */ +#define GPIO_MODER_MODE15_1 (0x2UL << GPIO_MODER_MODE15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_MODER_MODER0 GPIO_MODER_MODE0 +#define GPIO_MODER_MODER0_0 GPIO_MODER_MODE0_0 +#define GPIO_MODER_MODER0_1 GPIO_MODER_MODE0_1 +#define GPIO_MODER_MODER1 GPIO_MODER_MODE1 +#define GPIO_MODER_MODER1_0 GPIO_MODER_MODE1_0 +#define GPIO_MODER_MODER1_1 GPIO_MODER_MODE1_1 +#define GPIO_MODER_MODER2 GPIO_MODER_MODE2 +#define GPIO_MODER_MODER2_0 GPIO_MODER_MODE2_0 +#define GPIO_MODER_MODER2_1 GPIO_MODER_MODE2_1 +#define GPIO_MODER_MODER3 GPIO_MODER_MODE3 +#define GPIO_MODER_MODER3_0 GPIO_MODER_MODE3_0 +#define GPIO_MODER_MODER3_1 GPIO_MODER_MODE3_1 +#define GPIO_MODER_MODER4 GPIO_MODER_MODE4 +#define GPIO_MODER_MODER4_0 GPIO_MODER_MODE4_0 +#define GPIO_MODER_MODER4_1 GPIO_MODER_MODE4_1 +#define GPIO_MODER_MODER5 GPIO_MODER_MODE5 +#define GPIO_MODER_MODER5_0 GPIO_MODER_MODE5_0 +#define GPIO_MODER_MODER5_1 GPIO_MODER_MODE5_1 +#define GPIO_MODER_MODER6 GPIO_MODER_MODE6 +#define GPIO_MODER_MODER6_0 GPIO_MODER_MODE6_0 +#define GPIO_MODER_MODER6_1 GPIO_MODER_MODE6_1 +#define GPIO_MODER_MODER7 GPIO_MODER_MODE7 +#define GPIO_MODER_MODER7_0 GPIO_MODER_MODE7_0 +#define GPIO_MODER_MODER7_1 GPIO_MODER_MODE7_1 +#define GPIO_MODER_MODER8 GPIO_MODER_MODE8 +#define GPIO_MODER_MODER8_0 GPIO_MODER_MODE8_0 +#define GPIO_MODER_MODER8_1 GPIO_MODER_MODE8_1 +#define GPIO_MODER_MODER9 GPIO_MODER_MODE9 +#define GPIO_MODER_MODER9_0 GPIO_MODER_MODE9_0 +#define GPIO_MODER_MODER9_1 GPIO_MODER_MODE9_1 +#define GPIO_MODER_MODER10 GPIO_MODER_MODE10 +#define GPIO_MODER_MODER10_0 GPIO_MODER_MODE10_0 +#define GPIO_MODER_MODER10_1 GPIO_MODER_MODE10_1 +#define GPIO_MODER_MODER11 GPIO_MODER_MODE11 +#define GPIO_MODER_MODER11_0 GPIO_MODER_MODE11_0 +#define GPIO_MODER_MODER11_1 GPIO_MODER_MODE11_1 +#define GPIO_MODER_MODER12 GPIO_MODER_MODE12 +#define GPIO_MODER_MODER12_0 GPIO_MODER_MODE12_0 +#define GPIO_MODER_MODER12_1 GPIO_MODER_MODE12_1 +#define GPIO_MODER_MODER13 GPIO_MODER_MODE13 +#define GPIO_MODER_MODER13_0 GPIO_MODER_MODE13_0 +#define GPIO_MODER_MODER13_1 GPIO_MODER_MODE13_1 +#define GPIO_MODER_MODER14 GPIO_MODER_MODE14 +#define GPIO_MODER_MODER14_0 GPIO_MODER_MODE14_0 +#define GPIO_MODER_MODER14_1 GPIO_MODER_MODE14_1 +#define GPIO_MODER_MODER15 GPIO_MODER_MODE15 +#define GPIO_MODER_MODER15_0 GPIO_MODER_MODE15_0 +#define GPIO_MODER_MODER15_1 GPIO_MODER_MODE15_1 + +/****************** Bits definition for GPIO_OTYPER register ****************/ +#define GPIO_OTYPER_OT0_Pos (0U) +#define GPIO_OTYPER_OT0_Msk (0x1UL << GPIO_OTYPER_OT0_Pos) /*!< 0x00000001 */ +#define GPIO_OTYPER_OT0 GPIO_OTYPER_OT0_Msk +#define GPIO_OTYPER_OT1_Pos (1U) +#define GPIO_OTYPER_OT1_Msk (0x1UL << GPIO_OTYPER_OT1_Pos) /*!< 0x00000002 */ +#define GPIO_OTYPER_OT1 GPIO_OTYPER_OT1_Msk +#define GPIO_OTYPER_OT2_Pos (2U) +#define GPIO_OTYPER_OT2_Msk (0x1UL << GPIO_OTYPER_OT2_Pos) /*!< 0x00000004 */ +#define GPIO_OTYPER_OT2 GPIO_OTYPER_OT2_Msk +#define GPIO_OTYPER_OT3_Pos (3U) +#define GPIO_OTYPER_OT3_Msk (0x1UL << GPIO_OTYPER_OT3_Pos) /*!< 0x00000008 */ +#define GPIO_OTYPER_OT3 GPIO_OTYPER_OT3_Msk +#define GPIO_OTYPER_OT4_Pos (4U) +#define GPIO_OTYPER_OT4_Msk (0x1UL << GPIO_OTYPER_OT4_Pos) /*!< 0x00000010 */ +#define GPIO_OTYPER_OT4 GPIO_OTYPER_OT4_Msk +#define GPIO_OTYPER_OT5_Pos (5U) +#define GPIO_OTYPER_OT5_Msk (0x1UL << GPIO_OTYPER_OT5_Pos) /*!< 0x00000020 */ +#define GPIO_OTYPER_OT5 GPIO_OTYPER_OT5_Msk +#define GPIO_OTYPER_OT6_Pos (6U) +#define GPIO_OTYPER_OT6_Msk (0x1UL << GPIO_OTYPER_OT6_Pos) /*!< 0x00000040 */ +#define GPIO_OTYPER_OT6 GPIO_OTYPER_OT6_Msk +#define GPIO_OTYPER_OT7_Pos (7U) +#define GPIO_OTYPER_OT7_Msk (0x1UL << GPIO_OTYPER_OT7_Pos) /*!< 0x00000080 */ +#define GPIO_OTYPER_OT7 GPIO_OTYPER_OT7_Msk +#define GPIO_OTYPER_OT8_Pos (8U) +#define GPIO_OTYPER_OT8_Msk (0x1UL << GPIO_OTYPER_OT8_Pos) /*!< 0x00000100 */ +#define GPIO_OTYPER_OT8 GPIO_OTYPER_OT8_Msk +#define GPIO_OTYPER_OT9_Pos (9U) +#define GPIO_OTYPER_OT9_Msk (0x1UL << GPIO_OTYPER_OT9_Pos) /*!< 0x00000200 */ +#define GPIO_OTYPER_OT9 GPIO_OTYPER_OT9_Msk +#define GPIO_OTYPER_OT10_Pos (10U) +#define GPIO_OTYPER_OT10_Msk (0x1UL << GPIO_OTYPER_OT10_Pos) /*!< 0x00000400 */ +#define GPIO_OTYPER_OT10 GPIO_OTYPER_OT10_Msk +#define GPIO_OTYPER_OT11_Pos (11U) +#define GPIO_OTYPER_OT11_Msk (0x1UL << GPIO_OTYPER_OT11_Pos) /*!< 0x00000800 */ +#define GPIO_OTYPER_OT11 GPIO_OTYPER_OT11_Msk +#define GPIO_OTYPER_OT12_Pos (12U) +#define GPIO_OTYPER_OT12_Msk (0x1UL << GPIO_OTYPER_OT12_Pos) /*!< 0x00001000 */ +#define GPIO_OTYPER_OT12 GPIO_OTYPER_OT12_Msk +#define GPIO_OTYPER_OT13_Pos (13U) +#define GPIO_OTYPER_OT13_Msk (0x1UL << GPIO_OTYPER_OT13_Pos) /*!< 0x00002000 */ +#define GPIO_OTYPER_OT13 GPIO_OTYPER_OT13_Msk +#define GPIO_OTYPER_OT14_Pos (14U) +#define GPIO_OTYPER_OT14_Msk (0x1UL << GPIO_OTYPER_OT14_Pos) /*!< 0x00004000 */ +#define GPIO_OTYPER_OT14 GPIO_OTYPER_OT14_Msk +#define GPIO_OTYPER_OT15_Pos (15U) +#define GPIO_OTYPER_OT15_Msk (0x1UL << GPIO_OTYPER_OT15_Pos) /*!< 0x00008000 */ +#define GPIO_OTYPER_OT15 GPIO_OTYPER_OT15_Msk + +/* Legacy defines */ +#define GPIO_OTYPER_OT_0 GPIO_OTYPER_OT0 +#define GPIO_OTYPER_OT_1 GPIO_OTYPER_OT1 +#define GPIO_OTYPER_OT_2 GPIO_OTYPER_OT2 +#define GPIO_OTYPER_OT_3 GPIO_OTYPER_OT3 +#define GPIO_OTYPER_OT_4 GPIO_OTYPER_OT4 +#define GPIO_OTYPER_OT_5 GPIO_OTYPER_OT5 +#define GPIO_OTYPER_OT_6 GPIO_OTYPER_OT6 +#define GPIO_OTYPER_OT_7 GPIO_OTYPER_OT7 +#define GPIO_OTYPER_OT_8 GPIO_OTYPER_OT8 +#define GPIO_OTYPER_OT_9 GPIO_OTYPER_OT9 +#define GPIO_OTYPER_OT_10 GPIO_OTYPER_OT10 +#define GPIO_OTYPER_OT_11 GPIO_OTYPER_OT11 +#define GPIO_OTYPER_OT_12 GPIO_OTYPER_OT12 +#define GPIO_OTYPER_OT_13 GPIO_OTYPER_OT13 +#define GPIO_OTYPER_OT_14 GPIO_OTYPER_OT14 +#define GPIO_OTYPER_OT_15 GPIO_OTYPER_OT15 + +/****************** Bits definition for GPIO_OSPEEDR register ***************/ +#define GPIO_OSPEEDR_OSPEED0_Pos (0U) +#define GPIO_OSPEEDR_OSPEED0_Msk (0x3UL << GPIO_OSPEEDR_OSPEED0_Pos) /*!< 0x00000003 */ +#define GPIO_OSPEEDR_OSPEED0 GPIO_OSPEEDR_OSPEED0_Msk +#define GPIO_OSPEEDR_OSPEED0_0 (0x1UL << GPIO_OSPEEDR_OSPEED0_Pos) /*!< 0x00000001 */ +#define GPIO_OSPEEDR_OSPEED0_1 (0x2UL << GPIO_OSPEEDR_OSPEED0_Pos) /*!< 0x00000002 */ +#define GPIO_OSPEEDR_OSPEED1_Pos (2U) +#define GPIO_OSPEEDR_OSPEED1_Msk (0x3UL << GPIO_OSPEEDR_OSPEED1_Pos) /*!< 0x0000000C */ +#define GPIO_OSPEEDR_OSPEED1 GPIO_OSPEEDR_OSPEED1_Msk +#define GPIO_OSPEEDR_OSPEED1_0 (0x1UL << GPIO_OSPEEDR_OSPEED1_Pos) /*!< 0x00000004 */ +#define GPIO_OSPEEDR_OSPEED1_1 (0x2UL << GPIO_OSPEEDR_OSPEED1_Pos) /*!< 0x00000008 */ +#define GPIO_OSPEEDR_OSPEED2_Pos (4U) +#define GPIO_OSPEEDR_OSPEED2_Msk (0x3UL << GPIO_OSPEEDR_OSPEED2_Pos) /*!< 0x00000030 */ +#define GPIO_OSPEEDR_OSPEED2 GPIO_OSPEEDR_OSPEED2_Msk +#define GPIO_OSPEEDR_OSPEED2_0 (0x1UL << GPIO_OSPEEDR_OSPEED2_Pos) /*!< 0x00000010 */ +#define GPIO_OSPEEDR_OSPEED2_1 (0x2UL << GPIO_OSPEEDR_OSPEED2_Pos) /*!< 0x00000020 */ +#define GPIO_OSPEEDR_OSPEED3_Pos (6U) +#define GPIO_OSPEEDR_OSPEED3_Msk (0x3UL << GPIO_OSPEEDR_OSPEED3_Pos) /*!< 0x000000C0 */ +#define GPIO_OSPEEDR_OSPEED3 GPIO_OSPEEDR_OSPEED3_Msk +#define GPIO_OSPEEDR_OSPEED3_0 (0x1UL << GPIO_OSPEEDR_OSPEED3_Pos) /*!< 0x00000040 */ +#define GPIO_OSPEEDR_OSPEED3_1 (0x2UL << GPIO_OSPEEDR_OSPEED3_Pos) /*!< 0x00000080 */ +#define GPIO_OSPEEDR_OSPEED4_Pos (8U) +#define GPIO_OSPEEDR_OSPEED4_Msk (0x3UL << GPIO_OSPEEDR_OSPEED4_Pos) /*!< 0x00000300 */ +#define GPIO_OSPEEDR_OSPEED4 GPIO_OSPEEDR_OSPEED4_Msk +#define GPIO_OSPEEDR_OSPEED4_0 (0x1UL << GPIO_OSPEEDR_OSPEED4_Pos) /*!< 0x00000100 */ +#define GPIO_OSPEEDR_OSPEED4_1 (0x2UL << GPIO_OSPEEDR_OSPEED4_Pos) /*!< 0x00000200 */ +#define GPIO_OSPEEDR_OSPEED5_Pos (10U) +#define GPIO_OSPEEDR_OSPEED5_Msk (0x3UL << GPIO_OSPEEDR_OSPEED5_Pos) /*!< 0x00000C00 */ +#define GPIO_OSPEEDR_OSPEED5 GPIO_OSPEEDR_OSPEED5_Msk +#define GPIO_OSPEEDR_OSPEED5_0 (0x1UL << GPIO_OSPEEDR_OSPEED5_Pos) /*!< 0x00000400 */ +#define GPIO_OSPEEDR_OSPEED5_1 (0x2UL << GPIO_OSPEEDR_OSPEED5_Pos) /*!< 0x00000800 */ +#define GPIO_OSPEEDR_OSPEED6_Pos (12U) +#define GPIO_OSPEEDR_OSPEED6_Msk (0x3UL << GPIO_OSPEEDR_OSPEED6_Pos) /*!< 0x00003000 */ +#define GPIO_OSPEEDR_OSPEED6 GPIO_OSPEEDR_OSPEED6_Msk +#define GPIO_OSPEEDR_OSPEED6_0 (0x1UL << GPIO_OSPEEDR_OSPEED6_Pos) /*!< 0x00001000 */ +#define GPIO_OSPEEDR_OSPEED6_1 (0x2UL << GPIO_OSPEEDR_OSPEED6_Pos) /*!< 0x00002000 */ +#define GPIO_OSPEEDR_OSPEED7_Pos (14U) +#define GPIO_OSPEEDR_OSPEED7_Msk (0x3UL << GPIO_OSPEEDR_OSPEED7_Pos) /*!< 0x0000C000 */ +#define GPIO_OSPEEDR_OSPEED7 GPIO_OSPEEDR_OSPEED7_Msk +#define GPIO_OSPEEDR_OSPEED7_0 (0x1UL << GPIO_OSPEEDR_OSPEED7_Pos) /*!< 0x00004000 */ +#define GPIO_OSPEEDR_OSPEED7_1 (0x2UL << GPIO_OSPEEDR_OSPEED7_Pos) /*!< 0x00008000 */ +#define GPIO_OSPEEDR_OSPEED8_Pos (16U) +#define GPIO_OSPEEDR_OSPEED8_Msk (0x3UL << GPIO_OSPEEDR_OSPEED8_Pos) /*!< 0x00030000 */ +#define GPIO_OSPEEDR_OSPEED8 GPIO_OSPEEDR_OSPEED8_Msk +#define GPIO_OSPEEDR_OSPEED8_0 (0x1UL << GPIO_OSPEEDR_OSPEED8_Pos) /*!< 0x00010000 */ +#define GPIO_OSPEEDR_OSPEED8_1 (0x2UL << GPIO_OSPEEDR_OSPEED8_Pos) /*!< 0x00020000 */ +#define GPIO_OSPEEDR_OSPEED9_Pos (18U) +#define GPIO_OSPEEDR_OSPEED9_Msk (0x3UL << GPIO_OSPEEDR_OSPEED9_Pos) /*!< 0x000C0000 */ +#define GPIO_OSPEEDR_OSPEED9 GPIO_OSPEEDR_OSPEED9_Msk +#define GPIO_OSPEEDR_OSPEED9_0 (0x1UL << GPIO_OSPEEDR_OSPEED9_Pos) /*!< 0x00040000 */ +#define GPIO_OSPEEDR_OSPEED9_1 (0x2UL << GPIO_OSPEEDR_OSPEED9_Pos) /*!< 0x00080000 */ +#define GPIO_OSPEEDR_OSPEED10_Pos (20U) +#define GPIO_OSPEEDR_OSPEED10_Msk (0x3UL << GPIO_OSPEEDR_OSPEED10_Pos) /*!< 0x00300000 */ +#define GPIO_OSPEEDR_OSPEED10 GPIO_OSPEEDR_OSPEED10_Msk +#define GPIO_OSPEEDR_OSPEED10_0 (0x1UL << GPIO_OSPEEDR_OSPEED10_Pos) /*!< 0x00100000 */ +#define GPIO_OSPEEDR_OSPEED10_1 (0x2UL << GPIO_OSPEEDR_OSPEED10_Pos) /*!< 0x00200000 */ +#define GPIO_OSPEEDR_OSPEED11_Pos (22U) +#define GPIO_OSPEEDR_OSPEED11_Msk (0x3UL << GPIO_OSPEEDR_OSPEED11_Pos) /*!< 0x00C00000 */ +#define GPIO_OSPEEDR_OSPEED11 GPIO_OSPEEDR_OSPEED11_Msk +#define GPIO_OSPEEDR_OSPEED11_0 (0x1UL << GPIO_OSPEEDR_OSPEED11_Pos) /*!< 0x00400000 */ +#define GPIO_OSPEEDR_OSPEED11_1 (0x2UL << GPIO_OSPEEDR_OSPEED11_Pos) /*!< 0x00800000 */ +#define GPIO_OSPEEDR_OSPEED12_Pos (24U) +#define GPIO_OSPEEDR_OSPEED12_Msk (0x3UL << GPIO_OSPEEDR_OSPEED12_Pos) /*!< 0x03000000 */ +#define GPIO_OSPEEDR_OSPEED12 GPIO_OSPEEDR_OSPEED12_Msk +#define GPIO_OSPEEDR_OSPEED12_0 (0x1UL << GPIO_OSPEEDR_OSPEED12_Pos) /*!< 0x01000000 */ +#define GPIO_OSPEEDR_OSPEED12_1 (0x2UL << GPIO_OSPEEDR_OSPEED12_Pos) /*!< 0x02000000 */ +#define GPIO_OSPEEDR_OSPEED13_Pos (26U) +#define GPIO_OSPEEDR_OSPEED13_Msk (0x3UL << GPIO_OSPEEDR_OSPEED13_Pos) /*!< 0x0C000000 */ +#define GPIO_OSPEEDR_OSPEED13 GPIO_OSPEEDR_OSPEED13_Msk +#define GPIO_OSPEEDR_OSPEED13_0 (0x1UL << GPIO_OSPEEDR_OSPEED13_Pos) /*!< 0x04000000 */ +#define GPIO_OSPEEDR_OSPEED13_1 (0x2UL << GPIO_OSPEEDR_OSPEED13_Pos) /*!< 0x08000000 */ +#define GPIO_OSPEEDR_OSPEED14_Pos (28U) +#define GPIO_OSPEEDR_OSPEED14_Msk (0x3UL << GPIO_OSPEEDR_OSPEED14_Pos) /*!< 0x30000000 */ +#define GPIO_OSPEEDR_OSPEED14 GPIO_OSPEEDR_OSPEED14_Msk +#define GPIO_OSPEEDR_OSPEED14_0 (0x1UL << GPIO_OSPEEDR_OSPEED14_Pos) /*!< 0x10000000 */ +#define GPIO_OSPEEDR_OSPEED14_1 (0x2UL << GPIO_OSPEEDR_OSPEED14_Pos) /*!< 0x20000000 */ +#define GPIO_OSPEEDR_OSPEED15_Pos (30U) +#define GPIO_OSPEEDR_OSPEED15_Msk (0x3UL << GPIO_OSPEEDR_OSPEED15_Pos) /*!< 0xC0000000 */ +#define GPIO_OSPEEDR_OSPEED15 GPIO_OSPEEDR_OSPEED15_Msk +#define GPIO_OSPEEDR_OSPEED15_0 (0x1UL << GPIO_OSPEEDR_OSPEED15_Pos) /*!< 0x40000000 */ +#define GPIO_OSPEEDR_OSPEED15_1 (0x2UL << GPIO_OSPEEDR_OSPEED15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_OSPEEDER_OSPEEDR0 GPIO_OSPEEDR_OSPEED0 +#define GPIO_OSPEEDER_OSPEEDR0_0 GPIO_OSPEEDR_OSPEED0_0 +#define GPIO_OSPEEDER_OSPEEDR0_1 GPIO_OSPEEDR_OSPEED0_1 +#define GPIO_OSPEEDER_OSPEEDR1 GPIO_OSPEEDR_OSPEED1 +#define GPIO_OSPEEDER_OSPEEDR1_0 GPIO_OSPEEDR_OSPEED1_0 +#define GPIO_OSPEEDER_OSPEEDR1_1 GPIO_OSPEEDR_OSPEED1_1 +#define GPIO_OSPEEDER_OSPEEDR2 GPIO_OSPEEDR_OSPEED2 +#define GPIO_OSPEEDER_OSPEEDR2_0 GPIO_OSPEEDR_OSPEED2_0 +#define GPIO_OSPEEDER_OSPEEDR2_1 GPIO_OSPEEDR_OSPEED2_1 +#define GPIO_OSPEEDER_OSPEEDR3 GPIO_OSPEEDR_OSPEED3 +#define GPIO_OSPEEDER_OSPEEDR3_0 GPIO_OSPEEDR_OSPEED3_0 +#define GPIO_OSPEEDER_OSPEEDR3_1 GPIO_OSPEEDR_OSPEED3_1 +#define GPIO_OSPEEDER_OSPEEDR4 GPIO_OSPEEDR_OSPEED4 +#define GPIO_OSPEEDER_OSPEEDR4_0 GPIO_OSPEEDR_OSPEED4_0 +#define GPIO_OSPEEDER_OSPEEDR4_1 GPIO_OSPEEDR_OSPEED4_1 +#define GPIO_OSPEEDER_OSPEEDR5 GPIO_OSPEEDR_OSPEED5 +#define GPIO_OSPEEDER_OSPEEDR5_0 GPIO_OSPEEDR_OSPEED5_0 +#define GPIO_OSPEEDER_OSPEEDR5_1 GPIO_OSPEEDR_OSPEED5_1 +#define GPIO_OSPEEDER_OSPEEDR6 GPIO_OSPEEDR_OSPEED6 +#define GPIO_OSPEEDER_OSPEEDR6_0 GPIO_OSPEEDR_OSPEED6_0 +#define GPIO_OSPEEDER_OSPEEDR6_1 GPIO_OSPEEDR_OSPEED6_1 +#define GPIO_OSPEEDER_OSPEEDR7 GPIO_OSPEEDR_OSPEED7 +#define GPIO_OSPEEDER_OSPEEDR7_0 GPIO_OSPEEDR_OSPEED7_0 +#define GPIO_OSPEEDER_OSPEEDR7_1 GPIO_OSPEEDR_OSPEED7_1 +#define GPIO_OSPEEDER_OSPEEDR8 GPIO_OSPEEDR_OSPEED8 +#define GPIO_OSPEEDER_OSPEEDR8_0 GPIO_OSPEEDR_OSPEED8_0 +#define GPIO_OSPEEDER_OSPEEDR8_1 GPIO_OSPEEDR_OSPEED8_1 +#define GPIO_OSPEEDER_OSPEEDR9 GPIO_OSPEEDR_OSPEED9 +#define GPIO_OSPEEDER_OSPEEDR9_0 GPIO_OSPEEDR_OSPEED9_0 +#define GPIO_OSPEEDER_OSPEEDR9_1 GPIO_OSPEEDR_OSPEED9_1 +#define GPIO_OSPEEDER_OSPEEDR10 GPIO_OSPEEDR_OSPEED10 +#define GPIO_OSPEEDER_OSPEEDR10_0 GPIO_OSPEEDR_OSPEED10_0 +#define GPIO_OSPEEDER_OSPEEDR10_1 GPIO_OSPEEDR_OSPEED10_1 +#define GPIO_OSPEEDER_OSPEEDR11 GPIO_OSPEEDR_OSPEED11 +#define GPIO_OSPEEDER_OSPEEDR11_0 GPIO_OSPEEDR_OSPEED11_0 +#define GPIO_OSPEEDER_OSPEEDR11_1 GPIO_OSPEEDR_OSPEED11_1 +#define GPIO_OSPEEDER_OSPEEDR12 GPIO_OSPEEDR_OSPEED12 +#define GPIO_OSPEEDER_OSPEEDR12_0 GPIO_OSPEEDR_OSPEED12_0 +#define GPIO_OSPEEDER_OSPEEDR12_1 GPIO_OSPEEDR_OSPEED12_1 +#define GPIO_OSPEEDER_OSPEEDR13 GPIO_OSPEEDR_OSPEED13 +#define GPIO_OSPEEDER_OSPEEDR13_0 GPIO_OSPEEDR_OSPEED13_0 +#define GPIO_OSPEEDER_OSPEEDR13_1 GPIO_OSPEEDR_OSPEED13_1 +#define GPIO_OSPEEDER_OSPEEDR14 GPIO_OSPEEDR_OSPEED14 +#define GPIO_OSPEEDER_OSPEEDR14_0 GPIO_OSPEEDR_OSPEED14_0 +#define GPIO_OSPEEDER_OSPEEDR14_1 GPIO_OSPEEDR_OSPEED14_1 +#define GPIO_OSPEEDER_OSPEEDR15 GPIO_OSPEEDR_OSPEED15 +#define GPIO_OSPEEDER_OSPEEDR15_0 GPIO_OSPEEDR_OSPEED15_0 +#define GPIO_OSPEEDER_OSPEEDR15_1 GPIO_OSPEEDR_OSPEED15_1 + +/****************** Bits definition for GPIO_PUPDR register *****************/ +#define GPIO_PUPDR_PUPD0_Pos (0U) +#define GPIO_PUPDR_PUPD0_Msk (0x3UL << GPIO_PUPDR_PUPD0_Pos) /*!< 0x00000003 */ +#define GPIO_PUPDR_PUPD0 GPIO_PUPDR_PUPD0_Msk +#define GPIO_PUPDR_PUPD0_0 (0x1UL << GPIO_PUPDR_PUPD0_Pos) /*!< 0x00000001 */ +#define GPIO_PUPDR_PUPD0_1 (0x2UL << GPIO_PUPDR_PUPD0_Pos) /*!< 0x00000002 */ +#define GPIO_PUPDR_PUPD1_Pos (2U) +#define GPIO_PUPDR_PUPD1_Msk (0x3UL << GPIO_PUPDR_PUPD1_Pos) /*!< 0x0000000C */ +#define GPIO_PUPDR_PUPD1 GPIO_PUPDR_PUPD1_Msk +#define GPIO_PUPDR_PUPD1_0 (0x1UL << GPIO_PUPDR_PUPD1_Pos) /*!< 0x00000004 */ +#define GPIO_PUPDR_PUPD1_1 (0x2UL << GPIO_PUPDR_PUPD1_Pos) /*!< 0x00000008 */ +#define GPIO_PUPDR_PUPD2_Pos (4U) +#define GPIO_PUPDR_PUPD2_Msk (0x3UL << GPIO_PUPDR_PUPD2_Pos) /*!< 0x00000030 */ +#define GPIO_PUPDR_PUPD2 GPIO_PUPDR_PUPD2_Msk +#define GPIO_PUPDR_PUPD2_0 (0x1UL << GPIO_PUPDR_PUPD2_Pos) /*!< 0x00000010 */ +#define GPIO_PUPDR_PUPD2_1 (0x2UL << GPIO_PUPDR_PUPD2_Pos) /*!< 0x00000020 */ +#define GPIO_PUPDR_PUPD3_Pos (6U) +#define GPIO_PUPDR_PUPD3_Msk (0x3UL << GPIO_PUPDR_PUPD3_Pos) /*!< 0x000000C0 */ +#define GPIO_PUPDR_PUPD3 GPIO_PUPDR_PUPD3_Msk +#define GPIO_PUPDR_PUPD3_0 (0x1UL << GPIO_PUPDR_PUPD3_Pos) /*!< 0x00000040 */ +#define GPIO_PUPDR_PUPD3_1 (0x2UL << GPIO_PUPDR_PUPD3_Pos) /*!< 0x00000080 */ +#define GPIO_PUPDR_PUPD4_Pos (8U) +#define GPIO_PUPDR_PUPD4_Msk (0x3UL << GPIO_PUPDR_PUPD4_Pos) /*!< 0x00000300 */ +#define GPIO_PUPDR_PUPD4 GPIO_PUPDR_PUPD4_Msk +#define GPIO_PUPDR_PUPD4_0 (0x1UL << GPIO_PUPDR_PUPD4_Pos) /*!< 0x00000100 */ +#define GPIO_PUPDR_PUPD4_1 (0x2UL << GPIO_PUPDR_PUPD4_Pos) /*!< 0x00000200 */ +#define GPIO_PUPDR_PUPD5_Pos (10U) +#define GPIO_PUPDR_PUPD5_Msk (0x3UL << GPIO_PUPDR_PUPD5_Pos) /*!< 0x00000C00 */ +#define GPIO_PUPDR_PUPD5 GPIO_PUPDR_PUPD5_Msk +#define GPIO_PUPDR_PUPD5_0 (0x1UL << GPIO_PUPDR_PUPD5_Pos) /*!< 0x00000400 */ +#define GPIO_PUPDR_PUPD5_1 (0x2UL << GPIO_PUPDR_PUPD5_Pos) /*!< 0x00000800 */ +#define GPIO_PUPDR_PUPD6_Pos (12U) +#define GPIO_PUPDR_PUPD6_Msk (0x3UL << GPIO_PUPDR_PUPD6_Pos) /*!< 0x00003000 */ +#define GPIO_PUPDR_PUPD6 GPIO_PUPDR_PUPD6_Msk +#define GPIO_PUPDR_PUPD6_0 (0x1UL << GPIO_PUPDR_PUPD6_Pos) /*!< 0x00001000 */ +#define GPIO_PUPDR_PUPD6_1 (0x2UL << GPIO_PUPDR_PUPD6_Pos) /*!< 0x00002000 */ +#define GPIO_PUPDR_PUPD7_Pos (14U) +#define GPIO_PUPDR_PUPD7_Msk (0x3UL << GPIO_PUPDR_PUPD7_Pos) /*!< 0x0000C000 */ +#define GPIO_PUPDR_PUPD7 GPIO_PUPDR_PUPD7_Msk +#define GPIO_PUPDR_PUPD7_0 (0x1UL << GPIO_PUPDR_PUPD7_Pos) /*!< 0x00004000 */ +#define GPIO_PUPDR_PUPD7_1 (0x2UL << GPIO_PUPDR_PUPD7_Pos) /*!< 0x00008000 */ +#define GPIO_PUPDR_PUPD8_Pos (16U) +#define GPIO_PUPDR_PUPD8_Msk (0x3UL << GPIO_PUPDR_PUPD8_Pos) /*!< 0x00030000 */ +#define GPIO_PUPDR_PUPD8 GPIO_PUPDR_PUPD8_Msk +#define GPIO_PUPDR_PUPD8_0 (0x1UL << GPIO_PUPDR_PUPD8_Pos) /*!< 0x00010000 */ +#define GPIO_PUPDR_PUPD8_1 (0x2UL << GPIO_PUPDR_PUPD8_Pos) /*!< 0x00020000 */ +#define GPIO_PUPDR_PUPD9_Pos (18U) +#define GPIO_PUPDR_PUPD9_Msk (0x3UL << GPIO_PUPDR_PUPD9_Pos) /*!< 0x000C0000 */ +#define GPIO_PUPDR_PUPD9 GPIO_PUPDR_PUPD9_Msk +#define GPIO_PUPDR_PUPD9_0 (0x1UL << GPIO_PUPDR_PUPD9_Pos) /*!< 0x00040000 */ +#define GPIO_PUPDR_PUPD9_1 (0x2UL << GPIO_PUPDR_PUPD9_Pos) /*!< 0x00080000 */ +#define GPIO_PUPDR_PUPD10_Pos (20U) +#define GPIO_PUPDR_PUPD10_Msk (0x3UL << GPIO_PUPDR_PUPD10_Pos) /*!< 0x00300000 */ +#define GPIO_PUPDR_PUPD10 GPIO_PUPDR_PUPD10_Msk +#define GPIO_PUPDR_PUPD10_0 (0x1UL << GPIO_PUPDR_PUPD10_Pos) /*!< 0x00100000 */ +#define GPIO_PUPDR_PUPD10_1 (0x2UL << GPIO_PUPDR_PUPD10_Pos) /*!< 0x00200000 */ +#define GPIO_PUPDR_PUPD11_Pos (22U) +#define GPIO_PUPDR_PUPD11_Msk (0x3UL << GPIO_PUPDR_PUPD11_Pos) /*!< 0x00C00000 */ +#define GPIO_PUPDR_PUPD11 GPIO_PUPDR_PUPD11_Msk +#define GPIO_PUPDR_PUPD11_0 (0x1UL << GPIO_PUPDR_PUPD11_Pos) /*!< 0x00400000 */ +#define GPIO_PUPDR_PUPD11_1 (0x2UL << GPIO_PUPDR_PUPD11_Pos) /*!< 0x00800000 */ +#define GPIO_PUPDR_PUPD12_Pos (24U) +#define GPIO_PUPDR_PUPD12_Msk (0x3UL << GPIO_PUPDR_PUPD12_Pos) /*!< 0x03000000 */ +#define GPIO_PUPDR_PUPD12 GPIO_PUPDR_PUPD12_Msk +#define GPIO_PUPDR_PUPD12_0 (0x1UL << GPIO_PUPDR_PUPD12_Pos) /*!< 0x01000000 */ +#define GPIO_PUPDR_PUPD12_1 (0x2UL << GPIO_PUPDR_PUPD12_Pos) /*!< 0x02000000 */ +#define GPIO_PUPDR_PUPD13_Pos (26U) +#define GPIO_PUPDR_PUPD13_Msk (0x3UL << GPIO_PUPDR_PUPD13_Pos) /*!< 0x0C000000 */ +#define GPIO_PUPDR_PUPD13 GPIO_PUPDR_PUPD13_Msk +#define GPIO_PUPDR_PUPD13_0 (0x1UL << GPIO_PUPDR_PUPD13_Pos) /*!< 0x04000000 */ +#define GPIO_PUPDR_PUPD13_1 (0x2UL << GPIO_PUPDR_PUPD13_Pos) /*!< 0x08000000 */ +#define GPIO_PUPDR_PUPD14_Pos (28U) +#define GPIO_PUPDR_PUPD14_Msk (0x3UL << GPIO_PUPDR_PUPD14_Pos) /*!< 0x30000000 */ +#define GPIO_PUPDR_PUPD14 GPIO_PUPDR_PUPD14_Msk +#define GPIO_PUPDR_PUPD14_0 (0x1UL << GPIO_PUPDR_PUPD14_Pos) /*!< 0x10000000 */ +#define GPIO_PUPDR_PUPD14_1 (0x2UL << GPIO_PUPDR_PUPD14_Pos) /*!< 0x20000000 */ +#define GPIO_PUPDR_PUPD15_Pos (30U) +#define GPIO_PUPDR_PUPD15_Msk (0x3UL << GPIO_PUPDR_PUPD15_Pos) /*!< 0xC0000000 */ +#define GPIO_PUPDR_PUPD15 GPIO_PUPDR_PUPD15_Msk +#define GPIO_PUPDR_PUPD15_0 (0x1UL << GPIO_PUPDR_PUPD15_Pos) /*!< 0x40000000 */ +#define GPIO_PUPDR_PUPD15_1 (0x2UL << GPIO_PUPDR_PUPD15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_PUPDR_PUPDR0 GPIO_PUPDR_PUPD0 +#define GPIO_PUPDR_PUPDR0_0 GPIO_PUPDR_PUPD0_0 +#define GPIO_PUPDR_PUPDR0_1 GPIO_PUPDR_PUPD0_1 +#define GPIO_PUPDR_PUPDR1 GPIO_PUPDR_PUPD1 +#define GPIO_PUPDR_PUPDR1_0 GPIO_PUPDR_PUPD1_0 +#define GPIO_PUPDR_PUPDR1_1 GPIO_PUPDR_PUPD1_1 +#define GPIO_PUPDR_PUPDR2 GPIO_PUPDR_PUPD2 +#define GPIO_PUPDR_PUPDR2_0 GPIO_PUPDR_PUPD2_0 +#define GPIO_PUPDR_PUPDR2_1 GPIO_PUPDR_PUPD2_1 +#define GPIO_PUPDR_PUPDR3 GPIO_PUPDR_PUPD3 +#define GPIO_PUPDR_PUPDR3_0 GPIO_PUPDR_PUPD3_0 +#define GPIO_PUPDR_PUPDR3_1 GPIO_PUPDR_PUPD3_1 +#define GPIO_PUPDR_PUPDR4 GPIO_PUPDR_PUPD4 +#define GPIO_PUPDR_PUPDR4_0 GPIO_PUPDR_PUPD4_0 +#define GPIO_PUPDR_PUPDR4_1 GPIO_PUPDR_PUPD4_1 +#define GPIO_PUPDR_PUPDR5 GPIO_PUPDR_PUPD5 +#define GPIO_PUPDR_PUPDR5_0 GPIO_PUPDR_PUPD5_0 +#define GPIO_PUPDR_PUPDR5_1 GPIO_PUPDR_PUPD5_1 +#define GPIO_PUPDR_PUPDR6 GPIO_PUPDR_PUPD6 +#define GPIO_PUPDR_PUPDR6_0 GPIO_PUPDR_PUPD6_0 +#define GPIO_PUPDR_PUPDR6_1 GPIO_PUPDR_PUPD6_1 +#define GPIO_PUPDR_PUPDR7 GPIO_PUPDR_PUPD7 +#define GPIO_PUPDR_PUPDR7_0 GPIO_PUPDR_PUPD7_0 +#define GPIO_PUPDR_PUPDR7_1 GPIO_PUPDR_PUPD7_1 +#define GPIO_PUPDR_PUPDR8 GPIO_PUPDR_PUPD8 +#define GPIO_PUPDR_PUPDR8_0 GPIO_PUPDR_PUPD8_0 +#define GPIO_PUPDR_PUPDR8_1 GPIO_PUPDR_PUPD8_1 +#define GPIO_PUPDR_PUPDR9 GPIO_PUPDR_PUPD9 +#define GPIO_PUPDR_PUPDR9_0 GPIO_PUPDR_PUPD9_0 +#define GPIO_PUPDR_PUPDR9_1 GPIO_PUPDR_PUPD9_1 +#define GPIO_PUPDR_PUPDR10 GPIO_PUPDR_PUPD10 +#define GPIO_PUPDR_PUPDR10_0 GPIO_PUPDR_PUPD10_0 +#define GPIO_PUPDR_PUPDR10_1 GPIO_PUPDR_PUPD10_1 +#define GPIO_PUPDR_PUPDR11 GPIO_PUPDR_PUPD11 +#define GPIO_PUPDR_PUPDR11_0 GPIO_PUPDR_PUPD11_0 +#define GPIO_PUPDR_PUPDR11_1 GPIO_PUPDR_PUPD11_1 +#define GPIO_PUPDR_PUPDR12 GPIO_PUPDR_PUPD12 +#define GPIO_PUPDR_PUPDR12_0 GPIO_PUPDR_PUPD12_0 +#define GPIO_PUPDR_PUPDR12_1 GPIO_PUPDR_PUPD12_1 +#define GPIO_PUPDR_PUPDR13 GPIO_PUPDR_PUPD13 +#define GPIO_PUPDR_PUPDR13_0 GPIO_PUPDR_PUPD13_0 +#define GPIO_PUPDR_PUPDR13_1 GPIO_PUPDR_PUPD13_1 +#define GPIO_PUPDR_PUPDR14 GPIO_PUPDR_PUPD14 +#define GPIO_PUPDR_PUPDR14_0 GPIO_PUPDR_PUPD14_0 +#define GPIO_PUPDR_PUPDR14_1 GPIO_PUPDR_PUPD14_1 +#define GPIO_PUPDR_PUPDR15 GPIO_PUPDR_PUPD15 +#define GPIO_PUPDR_PUPDR15_0 GPIO_PUPDR_PUPD15_0 +#define GPIO_PUPDR_PUPDR15_1 GPIO_PUPDR_PUPD15_1 + +/****************** Bits definition for GPIO_IDR register *******************/ +#define GPIO_IDR_ID0_Pos (0U) +#define GPIO_IDR_ID0_Msk (0x1UL << GPIO_IDR_ID0_Pos) /*!< 0x00000001 */ +#define GPIO_IDR_ID0 GPIO_IDR_ID0_Msk +#define GPIO_IDR_ID1_Pos (1U) +#define GPIO_IDR_ID1_Msk (0x1UL << GPIO_IDR_ID1_Pos) /*!< 0x00000002 */ +#define GPIO_IDR_ID1 GPIO_IDR_ID1_Msk +#define GPIO_IDR_ID2_Pos (2U) +#define GPIO_IDR_ID2_Msk (0x1UL << GPIO_IDR_ID2_Pos) /*!< 0x00000004 */ +#define GPIO_IDR_ID2 GPIO_IDR_ID2_Msk +#define GPIO_IDR_ID3_Pos (3U) +#define GPIO_IDR_ID3_Msk (0x1UL << GPIO_IDR_ID3_Pos) /*!< 0x00000008 */ +#define GPIO_IDR_ID3 GPIO_IDR_ID3_Msk +#define GPIO_IDR_ID4_Pos (4U) +#define GPIO_IDR_ID4_Msk (0x1UL << GPIO_IDR_ID4_Pos) /*!< 0x00000010 */ +#define GPIO_IDR_ID4 GPIO_IDR_ID4_Msk +#define GPIO_IDR_ID5_Pos (5U) +#define GPIO_IDR_ID5_Msk (0x1UL << GPIO_IDR_ID5_Pos) /*!< 0x00000020 */ +#define GPIO_IDR_ID5 GPIO_IDR_ID5_Msk +#define GPIO_IDR_ID6_Pos (6U) +#define GPIO_IDR_ID6_Msk (0x1UL << GPIO_IDR_ID6_Pos) /*!< 0x00000040 */ +#define GPIO_IDR_ID6 GPIO_IDR_ID6_Msk +#define GPIO_IDR_ID7_Pos (7U) +#define GPIO_IDR_ID7_Msk (0x1UL << GPIO_IDR_ID7_Pos) /*!< 0x00000080 */ +#define GPIO_IDR_ID7 GPIO_IDR_ID7_Msk +#define GPIO_IDR_ID8_Pos (8U) +#define GPIO_IDR_ID8_Msk (0x1UL << GPIO_IDR_ID8_Pos) /*!< 0x00000100 */ +#define GPIO_IDR_ID8 GPIO_IDR_ID8_Msk +#define GPIO_IDR_ID9_Pos (9U) +#define GPIO_IDR_ID9_Msk (0x1UL << GPIO_IDR_ID9_Pos) /*!< 0x00000200 */ +#define GPIO_IDR_ID9 GPIO_IDR_ID9_Msk +#define GPIO_IDR_ID10_Pos (10U) +#define GPIO_IDR_ID10_Msk (0x1UL << GPIO_IDR_ID10_Pos) /*!< 0x00000400 */ +#define GPIO_IDR_ID10 GPIO_IDR_ID10_Msk +#define GPIO_IDR_ID11_Pos (11U) +#define GPIO_IDR_ID11_Msk (0x1UL << GPIO_IDR_ID11_Pos) /*!< 0x00000800 */ +#define GPIO_IDR_ID11 GPIO_IDR_ID11_Msk +#define GPIO_IDR_ID12_Pos (12U) +#define GPIO_IDR_ID12_Msk (0x1UL << GPIO_IDR_ID12_Pos) /*!< 0x00001000 */ +#define GPIO_IDR_ID12 GPIO_IDR_ID12_Msk +#define GPIO_IDR_ID13_Pos (13U) +#define GPIO_IDR_ID13_Msk (0x1UL << GPIO_IDR_ID13_Pos) /*!< 0x00002000 */ +#define GPIO_IDR_ID13 GPIO_IDR_ID13_Msk +#define GPIO_IDR_ID14_Pos (14U) +#define GPIO_IDR_ID14_Msk (0x1UL << GPIO_IDR_ID14_Pos) /*!< 0x00004000 */ +#define GPIO_IDR_ID14 GPIO_IDR_ID14_Msk +#define GPIO_IDR_ID15_Pos (15U) +#define GPIO_IDR_ID15_Msk (0x1UL << GPIO_IDR_ID15_Pos) /*!< 0x00008000 */ +#define GPIO_IDR_ID15 GPIO_IDR_ID15_Msk + +/* Legacy defines */ +#define GPIO_IDR_IDR_0 GPIO_IDR_ID0 +#define GPIO_IDR_IDR_1 GPIO_IDR_ID1 +#define GPIO_IDR_IDR_2 GPIO_IDR_ID2 +#define GPIO_IDR_IDR_3 GPIO_IDR_ID3 +#define GPIO_IDR_IDR_4 GPIO_IDR_ID4 +#define GPIO_IDR_IDR_5 GPIO_IDR_ID5 +#define GPIO_IDR_IDR_6 GPIO_IDR_ID6 +#define GPIO_IDR_IDR_7 GPIO_IDR_ID7 +#define GPIO_IDR_IDR_8 GPIO_IDR_ID8 +#define GPIO_IDR_IDR_9 GPIO_IDR_ID9 +#define GPIO_IDR_IDR_10 GPIO_IDR_ID10 +#define GPIO_IDR_IDR_11 GPIO_IDR_ID11 +#define GPIO_IDR_IDR_12 GPIO_IDR_ID12 +#define GPIO_IDR_IDR_13 GPIO_IDR_ID13 +#define GPIO_IDR_IDR_14 GPIO_IDR_ID14 +#define GPIO_IDR_IDR_15 GPIO_IDR_ID15 + +/* Old GPIO_IDR register bits definition, maintained for legacy purpose */ +#define GPIO_OTYPER_IDR_0 GPIO_IDR_ID0 +#define GPIO_OTYPER_IDR_1 GPIO_IDR_ID1 +#define GPIO_OTYPER_IDR_2 GPIO_IDR_ID2 +#define GPIO_OTYPER_IDR_3 GPIO_IDR_ID3 +#define GPIO_OTYPER_IDR_4 GPIO_IDR_ID4 +#define GPIO_OTYPER_IDR_5 GPIO_IDR_ID5 +#define GPIO_OTYPER_IDR_6 GPIO_IDR_ID6 +#define GPIO_OTYPER_IDR_7 GPIO_IDR_ID7 +#define GPIO_OTYPER_IDR_8 GPIO_IDR_ID8 +#define GPIO_OTYPER_IDR_9 GPIO_IDR_ID9 +#define GPIO_OTYPER_IDR_10 GPIO_IDR_ID10 +#define GPIO_OTYPER_IDR_11 GPIO_IDR_ID11 +#define GPIO_OTYPER_IDR_12 GPIO_IDR_ID12 +#define GPIO_OTYPER_IDR_13 GPIO_IDR_ID13 +#define GPIO_OTYPER_IDR_14 GPIO_IDR_ID14 +#define GPIO_OTYPER_IDR_15 GPIO_IDR_ID15 + +/****************** Bits definition for GPIO_ODR register *******************/ +#define GPIO_ODR_OD0_Pos (0U) +#define GPIO_ODR_OD0_Msk (0x1UL << GPIO_ODR_OD0_Pos) /*!< 0x00000001 */ +#define GPIO_ODR_OD0 GPIO_ODR_OD0_Msk +#define GPIO_ODR_OD1_Pos (1U) +#define GPIO_ODR_OD1_Msk (0x1UL << GPIO_ODR_OD1_Pos) /*!< 0x00000002 */ +#define GPIO_ODR_OD1 GPIO_ODR_OD1_Msk +#define GPIO_ODR_OD2_Pos (2U) +#define GPIO_ODR_OD2_Msk (0x1UL << GPIO_ODR_OD2_Pos) /*!< 0x00000004 */ +#define GPIO_ODR_OD2 GPIO_ODR_OD2_Msk +#define GPIO_ODR_OD3_Pos (3U) +#define GPIO_ODR_OD3_Msk (0x1UL << GPIO_ODR_OD3_Pos) /*!< 0x00000008 */ +#define GPIO_ODR_OD3 GPIO_ODR_OD3_Msk +#define GPIO_ODR_OD4_Pos (4U) +#define GPIO_ODR_OD4_Msk (0x1UL << GPIO_ODR_OD4_Pos) /*!< 0x00000010 */ +#define GPIO_ODR_OD4 GPIO_ODR_OD4_Msk +#define GPIO_ODR_OD5_Pos (5U) +#define GPIO_ODR_OD5_Msk (0x1UL << GPIO_ODR_OD5_Pos) /*!< 0x00000020 */ +#define GPIO_ODR_OD5 GPIO_ODR_OD5_Msk +#define GPIO_ODR_OD6_Pos (6U) +#define GPIO_ODR_OD6_Msk (0x1UL << GPIO_ODR_OD6_Pos) /*!< 0x00000040 */ +#define GPIO_ODR_OD6 GPIO_ODR_OD6_Msk +#define GPIO_ODR_OD7_Pos (7U) +#define GPIO_ODR_OD7_Msk (0x1UL << GPIO_ODR_OD7_Pos) /*!< 0x00000080 */ +#define GPIO_ODR_OD7 GPIO_ODR_OD7_Msk +#define GPIO_ODR_OD8_Pos (8U) +#define GPIO_ODR_OD8_Msk (0x1UL << GPIO_ODR_OD8_Pos) /*!< 0x00000100 */ +#define GPIO_ODR_OD8 GPIO_ODR_OD8_Msk +#define GPIO_ODR_OD9_Pos (9U) +#define GPIO_ODR_OD9_Msk (0x1UL << GPIO_ODR_OD9_Pos) /*!< 0x00000200 */ +#define GPIO_ODR_OD9 GPIO_ODR_OD9_Msk +#define GPIO_ODR_OD10_Pos (10U) +#define GPIO_ODR_OD10_Msk (0x1UL << GPIO_ODR_OD10_Pos) /*!< 0x00000400 */ +#define GPIO_ODR_OD10 GPIO_ODR_OD10_Msk +#define GPIO_ODR_OD11_Pos (11U) +#define GPIO_ODR_OD11_Msk (0x1UL << GPIO_ODR_OD11_Pos) /*!< 0x00000800 */ +#define GPIO_ODR_OD11 GPIO_ODR_OD11_Msk +#define GPIO_ODR_OD12_Pos (12U) +#define GPIO_ODR_OD12_Msk (0x1UL << GPIO_ODR_OD12_Pos) /*!< 0x00001000 */ +#define GPIO_ODR_OD12 GPIO_ODR_OD12_Msk +#define GPIO_ODR_OD13_Pos (13U) +#define GPIO_ODR_OD13_Msk (0x1UL << GPIO_ODR_OD13_Pos) /*!< 0x00002000 */ +#define GPIO_ODR_OD13 GPIO_ODR_OD13_Msk +#define GPIO_ODR_OD14_Pos (14U) +#define GPIO_ODR_OD14_Msk (0x1UL << GPIO_ODR_OD14_Pos) /*!< 0x00004000 */ +#define GPIO_ODR_OD14 GPIO_ODR_OD14_Msk +#define GPIO_ODR_OD15_Pos (15U) +#define GPIO_ODR_OD15_Msk (0x1UL << GPIO_ODR_OD15_Pos) /*!< 0x00008000 */ +#define GPIO_ODR_OD15 GPIO_ODR_OD15_Msk + +/* Legacy defines */ +#define GPIO_ODR_ODR_0 GPIO_ODR_OD0 +#define GPIO_ODR_ODR_1 GPIO_ODR_OD1 +#define GPIO_ODR_ODR_2 GPIO_ODR_OD2 +#define GPIO_ODR_ODR_3 GPIO_ODR_OD3 +#define GPIO_ODR_ODR_4 GPIO_ODR_OD4 +#define GPIO_ODR_ODR_5 GPIO_ODR_OD5 +#define GPIO_ODR_ODR_6 GPIO_ODR_OD6 +#define GPIO_ODR_ODR_7 GPIO_ODR_OD7 +#define GPIO_ODR_ODR_8 GPIO_ODR_OD8 +#define GPIO_ODR_ODR_9 GPIO_ODR_OD9 +#define GPIO_ODR_ODR_10 GPIO_ODR_OD10 +#define GPIO_ODR_ODR_11 GPIO_ODR_OD11 +#define GPIO_ODR_ODR_12 GPIO_ODR_OD12 +#define GPIO_ODR_ODR_13 GPIO_ODR_OD13 +#define GPIO_ODR_ODR_14 GPIO_ODR_OD14 +#define GPIO_ODR_ODR_15 GPIO_ODR_OD15 + +/* Old GPIO_ODR register bits definition, maintained for legacy purpose */ +#define GPIO_OTYPER_ODR_0 GPIO_ODR_OD0 +#define GPIO_OTYPER_ODR_1 GPIO_ODR_OD1 +#define GPIO_OTYPER_ODR_2 GPIO_ODR_OD2 +#define GPIO_OTYPER_ODR_3 GPIO_ODR_OD3 +#define GPIO_OTYPER_ODR_4 GPIO_ODR_OD4 +#define GPIO_OTYPER_ODR_5 GPIO_ODR_OD5 +#define GPIO_OTYPER_ODR_6 GPIO_ODR_OD6 +#define GPIO_OTYPER_ODR_7 GPIO_ODR_OD7 +#define GPIO_OTYPER_ODR_8 GPIO_ODR_OD8 +#define GPIO_OTYPER_ODR_9 GPIO_ODR_OD9 +#define GPIO_OTYPER_ODR_10 GPIO_ODR_OD10 +#define GPIO_OTYPER_ODR_11 GPIO_ODR_OD11 +#define GPIO_OTYPER_ODR_12 GPIO_ODR_OD12 +#define GPIO_OTYPER_ODR_13 GPIO_ODR_OD13 +#define GPIO_OTYPER_ODR_14 GPIO_ODR_OD14 +#define GPIO_OTYPER_ODR_15 GPIO_ODR_OD15 + +/****************** Bits definition for GPIO_BSRR register ******************/ +#define GPIO_BSRR_BS0_Pos (0U) +#define GPIO_BSRR_BS0_Msk (0x1UL << GPIO_BSRR_BS0_Pos) /*!< 0x00000001 */ +#define GPIO_BSRR_BS0 GPIO_BSRR_BS0_Msk +#define GPIO_BSRR_BS1_Pos (1U) +#define GPIO_BSRR_BS1_Msk (0x1UL << GPIO_BSRR_BS1_Pos) /*!< 0x00000002 */ +#define GPIO_BSRR_BS1 GPIO_BSRR_BS1_Msk +#define GPIO_BSRR_BS2_Pos (2U) +#define GPIO_BSRR_BS2_Msk (0x1UL << GPIO_BSRR_BS2_Pos) /*!< 0x00000004 */ +#define GPIO_BSRR_BS2 GPIO_BSRR_BS2_Msk +#define GPIO_BSRR_BS3_Pos (3U) +#define GPIO_BSRR_BS3_Msk (0x1UL << GPIO_BSRR_BS3_Pos) /*!< 0x00000008 */ +#define GPIO_BSRR_BS3 GPIO_BSRR_BS3_Msk +#define GPIO_BSRR_BS4_Pos (4U) +#define GPIO_BSRR_BS4_Msk (0x1UL << GPIO_BSRR_BS4_Pos) /*!< 0x00000010 */ +#define GPIO_BSRR_BS4 GPIO_BSRR_BS4_Msk +#define GPIO_BSRR_BS5_Pos (5U) +#define GPIO_BSRR_BS5_Msk (0x1UL << GPIO_BSRR_BS5_Pos) /*!< 0x00000020 */ +#define GPIO_BSRR_BS5 GPIO_BSRR_BS5_Msk +#define GPIO_BSRR_BS6_Pos (6U) +#define GPIO_BSRR_BS6_Msk (0x1UL << GPIO_BSRR_BS6_Pos) /*!< 0x00000040 */ +#define GPIO_BSRR_BS6 GPIO_BSRR_BS6_Msk +#define GPIO_BSRR_BS7_Pos (7U) +#define GPIO_BSRR_BS7_Msk (0x1UL << GPIO_BSRR_BS7_Pos) /*!< 0x00000080 */ +#define GPIO_BSRR_BS7 GPIO_BSRR_BS7_Msk +#define GPIO_BSRR_BS8_Pos (8U) +#define GPIO_BSRR_BS8_Msk (0x1UL << GPIO_BSRR_BS8_Pos) /*!< 0x00000100 */ +#define GPIO_BSRR_BS8 GPIO_BSRR_BS8_Msk +#define GPIO_BSRR_BS9_Pos (9U) +#define GPIO_BSRR_BS9_Msk (0x1UL << GPIO_BSRR_BS9_Pos) /*!< 0x00000200 */ +#define GPIO_BSRR_BS9 GPIO_BSRR_BS9_Msk +#define GPIO_BSRR_BS10_Pos (10U) +#define GPIO_BSRR_BS10_Msk (0x1UL << GPIO_BSRR_BS10_Pos) /*!< 0x00000400 */ +#define GPIO_BSRR_BS10 GPIO_BSRR_BS10_Msk +#define GPIO_BSRR_BS11_Pos (11U) +#define GPIO_BSRR_BS11_Msk (0x1UL << GPIO_BSRR_BS11_Pos) /*!< 0x00000800 */ +#define GPIO_BSRR_BS11 GPIO_BSRR_BS11_Msk +#define GPIO_BSRR_BS12_Pos (12U) +#define GPIO_BSRR_BS12_Msk (0x1UL << GPIO_BSRR_BS12_Pos) /*!< 0x00001000 */ +#define GPIO_BSRR_BS12 GPIO_BSRR_BS12_Msk +#define GPIO_BSRR_BS13_Pos (13U) +#define GPIO_BSRR_BS13_Msk (0x1UL << GPIO_BSRR_BS13_Pos) /*!< 0x00002000 */ +#define GPIO_BSRR_BS13 GPIO_BSRR_BS13_Msk +#define GPIO_BSRR_BS14_Pos (14U) +#define GPIO_BSRR_BS14_Msk (0x1UL << GPIO_BSRR_BS14_Pos) /*!< 0x00004000 */ +#define GPIO_BSRR_BS14 GPIO_BSRR_BS14_Msk +#define GPIO_BSRR_BS15_Pos (15U) +#define GPIO_BSRR_BS15_Msk (0x1UL << GPIO_BSRR_BS15_Pos) /*!< 0x00008000 */ +#define GPIO_BSRR_BS15 GPIO_BSRR_BS15_Msk +#define GPIO_BSRR_BR0_Pos (16U) +#define GPIO_BSRR_BR0_Msk (0x1UL << GPIO_BSRR_BR0_Pos) /*!< 0x00010000 */ +#define GPIO_BSRR_BR0 GPIO_BSRR_BR0_Msk +#define GPIO_BSRR_BR1_Pos (17U) +#define GPIO_BSRR_BR1_Msk (0x1UL << GPIO_BSRR_BR1_Pos) /*!< 0x00020000 */ +#define GPIO_BSRR_BR1 GPIO_BSRR_BR1_Msk +#define GPIO_BSRR_BR2_Pos (18U) +#define GPIO_BSRR_BR2_Msk (0x1UL << GPIO_BSRR_BR2_Pos) /*!< 0x00040000 */ +#define GPIO_BSRR_BR2 GPIO_BSRR_BR2_Msk +#define GPIO_BSRR_BR3_Pos (19U) +#define GPIO_BSRR_BR3_Msk (0x1UL << GPIO_BSRR_BR3_Pos) /*!< 0x00080000 */ +#define GPIO_BSRR_BR3 GPIO_BSRR_BR3_Msk +#define GPIO_BSRR_BR4_Pos (20U) +#define GPIO_BSRR_BR4_Msk (0x1UL << GPIO_BSRR_BR4_Pos) /*!< 0x00100000 */ +#define GPIO_BSRR_BR4 GPIO_BSRR_BR4_Msk +#define GPIO_BSRR_BR5_Pos (21U) +#define GPIO_BSRR_BR5_Msk (0x1UL << GPIO_BSRR_BR5_Pos) /*!< 0x00200000 */ +#define GPIO_BSRR_BR5 GPIO_BSRR_BR5_Msk +#define GPIO_BSRR_BR6_Pos (22U) +#define GPIO_BSRR_BR6_Msk (0x1UL << GPIO_BSRR_BR6_Pos) /*!< 0x00400000 */ +#define GPIO_BSRR_BR6 GPIO_BSRR_BR6_Msk +#define GPIO_BSRR_BR7_Pos (23U) +#define GPIO_BSRR_BR7_Msk (0x1UL << GPIO_BSRR_BR7_Pos) /*!< 0x00800000 */ +#define GPIO_BSRR_BR7 GPIO_BSRR_BR7_Msk +#define GPIO_BSRR_BR8_Pos (24U) +#define GPIO_BSRR_BR8_Msk (0x1UL << GPIO_BSRR_BR8_Pos) /*!< 0x01000000 */ +#define GPIO_BSRR_BR8 GPIO_BSRR_BR8_Msk +#define GPIO_BSRR_BR9_Pos (25U) +#define GPIO_BSRR_BR9_Msk (0x1UL << GPIO_BSRR_BR9_Pos) /*!< 0x02000000 */ +#define GPIO_BSRR_BR9 GPIO_BSRR_BR9_Msk +#define GPIO_BSRR_BR10_Pos (26U) +#define GPIO_BSRR_BR10_Msk (0x1UL << GPIO_BSRR_BR10_Pos) /*!< 0x04000000 */ +#define GPIO_BSRR_BR10 GPIO_BSRR_BR10_Msk +#define GPIO_BSRR_BR11_Pos (27U) +#define GPIO_BSRR_BR11_Msk (0x1UL << GPIO_BSRR_BR11_Pos) /*!< 0x08000000 */ +#define GPIO_BSRR_BR11 GPIO_BSRR_BR11_Msk +#define GPIO_BSRR_BR12_Pos (28U) +#define GPIO_BSRR_BR12_Msk (0x1UL << GPIO_BSRR_BR12_Pos) /*!< 0x10000000 */ +#define GPIO_BSRR_BR12 GPIO_BSRR_BR12_Msk +#define GPIO_BSRR_BR13_Pos (29U) +#define GPIO_BSRR_BR13_Msk (0x1UL << GPIO_BSRR_BR13_Pos) /*!< 0x20000000 */ +#define GPIO_BSRR_BR13 GPIO_BSRR_BR13_Msk +#define GPIO_BSRR_BR14_Pos (30U) +#define GPIO_BSRR_BR14_Msk (0x1UL << GPIO_BSRR_BR14_Pos) /*!< 0x40000000 */ +#define GPIO_BSRR_BR14 GPIO_BSRR_BR14_Msk +#define GPIO_BSRR_BR15_Pos (31U) +#define GPIO_BSRR_BR15_Msk (0x1UL << GPIO_BSRR_BR15_Pos) /*!< 0x80000000 */ +#define GPIO_BSRR_BR15 GPIO_BSRR_BR15_Msk + +/* Legacy defines */ +#define GPIO_BSRR_BS_0 GPIO_BSRR_BS0 +#define GPIO_BSRR_BS_1 GPIO_BSRR_BS1 +#define GPIO_BSRR_BS_2 GPIO_BSRR_BS2 +#define GPIO_BSRR_BS_3 GPIO_BSRR_BS3 +#define GPIO_BSRR_BS_4 GPIO_BSRR_BS4 +#define GPIO_BSRR_BS_5 GPIO_BSRR_BS5 +#define GPIO_BSRR_BS_6 GPIO_BSRR_BS6 +#define GPIO_BSRR_BS_7 GPIO_BSRR_BS7 +#define GPIO_BSRR_BS_8 GPIO_BSRR_BS8 +#define GPIO_BSRR_BS_9 GPIO_BSRR_BS9 +#define GPIO_BSRR_BS_10 GPIO_BSRR_BS10 +#define GPIO_BSRR_BS_11 GPIO_BSRR_BS11 +#define GPIO_BSRR_BS_12 GPIO_BSRR_BS12 +#define GPIO_BSRR_BS_13 GPIO_BSRR_BS13 +#define GPIO_BSRR_BS_14 GPIO_BSRR_BS14 +#define GPIO_BSRR_BS_15 GPIO_BSRR_BS15 +#define GPIO_BSRR_BR_0 GPIO_BSRR_BR0 +#define GPIO_BSRR_BR_1 GPIO_BSRR_BR1 +#define GPIO_BSRR_BR_2 GPIO_BSRR_BR2 +#define GPIO_BSRR_BR_3 GPIO_BSRR_BR3 +#define GPIO_BSRR_BR_4 GPIO_BSRR_BR4 +#define GPIO_BSRR_BR_5 GPIO_BSRR_BR5 +#define GPIO_BSRR_BR_6 GPIO_BSRR_BR6 +#define GPIO_BSRR_BR_7 GPIO_BSRR_BR7 +#define GPIO_BSRR_BR_8 GPIO_BSRR_BR8 +#define GPIO_BSRR_BR_9 GPIO_BSRR_BR9 +#define GPIO_BSRR_BR_10 GPIO_BSRR_BR10 +#define GPIO_BSRR_BR_11 GPIO_BSRR_BR11 +#define GPIO_BSRR_BR_12 GPIO_BSRR_BR12 +#define GPIO_BSRR_BR_13 GPIO_BSRR_BR13 +#define GPIO_BSRR_BR_14 GPIO_BSRR_BR14 +#define GPIO_BSRR_BR_15 GPIO_BSRR_BR15 + +/****************** Bit definition for GPIO_LCKR register *********************/ +#define GPIO_LCKR_LCK0_Pos (0U) +#define GPIO_LCKR_LCK0_Msk (0x1UL << GPIO_LCKR_LCK0_Pos) /*!< 0x00000001 */ +#define GPIO_LCKR_LCK0 GPIO_LCKR_LCK0_Msk +#define GPIO_LCKR_LCK1_Pos (1U) +#define GPIO_LCKR_LCK1_Msk (0x1UL << GPIO_LCKR_LCK1_Pos) /*!< 0x00000002 */ +#define GPIO_LCKR_LCK1 GPIO_LCKR_LCK1_Msk +#define GPIO_LCKR_LCK2_Pos (2U) +#define GPIO_LCKR_LCK2_Msk (0x1UL << GPIO_LCKR_LCK2_Pos) /*!< 0x00000004 */ +#define GPIO_LCKR_LCK2 GPIO_LCKR_LCK2_Msk +#define GPIO_LCKR_LCK3_Pos (3U) +#define GPIO_LCKR_LCK3_Msk (0x1UL << GPIO_LCKR_LCK3_Pos) /*!< 0x00000008 */ +#define GPIO_LCKR_LCK3 GPIO_LCKR_LCK3_Msk +#define GPIO_LCKR_LCK4_Pos (4U) +#define GPIO_LCKR_LCK4_Msk (0x1UL << GPIO_LCKR_LCK4_Pos) /*!< 0x00000010 */ +#define GPIO_LCKR_LCK4 GPIO_LCKR_LCK4_Msk +#define GPIO_LCKR_LCK5_Pos (5U) +#define GPIO_LCKR_LCK5_Msk (0x1UL << GPIO_LCKR_LCK5_Pos) /*!< 0x00000020 */ +#define GPIO_LCKR_LCK5 GPIO_LCKR_LCK5_Msk +#define GPIO_LCKR_LCK6_Pos (6U) +#define GPIO_LCKR_LCK6_Msk (0x1UL << GPIO_LCKR_LCK6_Pos) /*!< 0x00000040 */ +#define GPIO_LCKR_LCK6 GPIO_LCKR_LCK6_Msk +#define GPIO_LCKR_LCK7_Pos (7U) +#define GPIO_LCKR_LCK7_Msk (0x1UL << GPIO_LCKR_LCK7_Pos) /*!< 0x00000080 */ +#define GPIO_LCKR_LCK7 GPIO_LCKR_LCK7_Msk +#define GPIO_LCKR_LCK8_Pos (8U) +#define GPIO_LCKR_LCK8_Msk (0x1UL << GPIO_LCKR_LCK8_Pos) /*!< 0x00000100 */ +#define GPIO_LCKR_LCK8 GPIO_LCKR_LCK8_Msk +#define GPIO_LCKR_LCK9_Pos (9U) +#define GPIO_LCKR_LCK9_Msk (0x1UL << GPIO_LCKR_LCK9_Pos) /*!< 0x00000200 */ +#define GPIO_LCKR_LCK9 GPIO_LCKR_LCK9_Msk +#define GPIO_LCKR_LCK10_Pos (10U) +#define GPIO_LCKR_LCK10_Msk (0x1UL << GPIO_LCKR_LCK10_Pos) /*!< 0x00000400 */ +#define GPIO_LCKR_LCK10 GPIO_LCKR_LCK10_Msk +#define GPIO_LCKR_LCK11_Pos (11U) +#define GPIO_LCKR_LCK11_Msk (0x1UL << GPIO_LCKR_LCK11_Pos) /*!< 0x00000800 */ +#define GPIO_LCKR_LCK11 GPIO_LCKR_LCK11_Msk +#define GPIO_LCKR_LCK12_Pos (12U) +#define GPIO_LCKR_LCK12_Msk (0x1UL << GPIO_LCKR_LCK12_Pos) /*!< 0x00001000 */ +#define GPIO_LCKR_LCK12 GPIO_LCKR_LCK12_Msk +#define GPIO_LCKR_LCK13_Pos (13U) +#define GPIO_LCKR_LCK13_Msk (0x1UL << GPIO_LCKR_LCK13_Pos) /*!< 0x00002000 */ +#define GPIO_LCKR_LCK13 GPIO_LCKR_LCK13_Msk +#define GPIO_LCKR_LCK14_Pos (14U) +#define GPIO_LCKR_LCK14_Msk (0x1UL << GPIO_LCKR_LCK14_Pos) /*!< 0x00004000 */ +#define GPIO_LCKR_LCK14 GPIO_LCKR_LCK14_Msk +#define GPIO_LCKR_LCK15_Pos (15U) +#define GPIO_LCKR_LCK15_Msk (0x1UL << GPIO_LCKR_LCK15_Pos) /*!< 0x00008000 */ +#define GPIO_LCKR_LCK15 GPIO_LCKR_LCK15_Msk +#define GPIO_LCKR_LCKK_Pos (16U) +#define GPIO_LCKR_LCKK_Msk (0x1UL << GPIO_LCKR_LCKK_Pos) /*!< 0x00010000 */ +#define GPIO_LCKR_LCKK GPIO_LCKR_LCKK_Msk + +/****************** Bit definition for GPIO_AFRL register *********************/ +#define GPIO_AFRL_AFSEL0_Pos (0U) +#define GPIO_AFRL_AFSEL0_Msk (0xFUL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x0000000F */ +#define GPIO_AFRL_AFSEL0 GPIO_AFRL_AFSEL0_Msk +#define GPIO_AFRL_AFSEL0_0 (0x1UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000001 */ +#define GPIO_AFRL_AFSEL0_1 (0x2UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000002 */ +#define GPIO_AFRL_AFSEL0_2 (0x4UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000004 */ +#define GPIO_AFRL_AFSEL0_3 (0x8UL << GPIO_AFRL_AFSEL0_Pos) /*!< 0x00000008 */ +#define GPIO_AFRL_AFSEL1_Pos (4U) +#define GPIO_AFRL_AFSEL1_Msk (0xFUL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x000000F0 */ +#define GPIO_AFRL_AFSEL1 GPIO_AFRL_AFSEL1_Msk +#define GPIO_AFRL_AFSEL1_0 (0x1UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000010 */ +#define GPIO_AFRL_AFSEL1_1 (0x2UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000020 */ +#define GPIO_AFRL_AFSEL1_2 (0x4UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000040 */ +#define GPIO_AFRL_AFSEL1_3 (0x8UL << GPIO_AFRL_AFSEL1_Pos) /*!< 0x00000080 */ +#define GPIO_AFRL_AFSEL2_Pos (8U) +#define GPIO_AFRL_AFSEL2_Msk (0xFUL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000F00 */ +#define GPIO_AFRL_AFSEL2 GPIO_AFRL_AFSEL2_Msk +#define GPIO_AFRL_AFSEL2_0 (0x1UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000100 */ +#define GPIO_AFRL_AFSEL2_1 (0x2UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000200 */ +#define GPIO_AFRL_AFSEL2_2 (0x4UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000400 */ +#define GPIO_AFRL_AFSEL2_3 (0x8UL << GPIO_AFRL_AFSEL2_Pos) /*!< 0x00000800 */ +#define GPIO_AFRL_AFSEL3_Pos (12U) +#define GPIO_AFRL_AFSEL3_Msk (0xFUL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x0000F000 */ +#define GPIO_AFRL_AFSEL3 GPIO_AFRL_AFSEL3_Msk +#define GPIO_AFRL_AFSEL3_0 (0x1UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00001000 */ +#define GPIO_AFRL_AFSEL3_1 (0x2UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00002000 */ +#define GPIO_AFRL_AFSEL3_2 (0x4UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00004000 */ +#define GPIO_AFRL_AFSEL3_3 (0x8UL << GPIO_AFRL_AFSEL3_Pos) /*!< 0x00008000 */ +#define GPIO_AFRL_AFSEL4_Pos (16U) +#define GPIO_AFRL_AFSEL4_Msk (0xFUL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x000F0000 */ +#define GPIO_AFRL_AFSEL4 GPIO_AFRL_AFSEL4_Msk +#define GPIO_AFRL_AFSEL4_0 (0x1UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00010000 */ +#define GPIO_AFRL_AFSEL4_1 (0x2UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00020000 */ +#define GPIO_AFRL_AFSEL4_2 (0x4UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00040000 */ +#define GPIO_AFRL_AFSEL4_3 (0x8UL << GPIO_AFRL_AFSEL4_Pos) /*!< 0x00080000 */ +#define GPIO_AFRL_AFSEL5_Pos (20U) +#define GPIO_AFRL_AFSEL5_Msk (0xFUL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00F00000 */ +#define GPIO_AFRL_AFSEL5 GPIO_AFRL_AFSEL5_Msk +#define GPIO_AFRL_AFSEL5_0 (0x1UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00100000 */ +#define GPIO_AFRL_AFSEL5_1 (0x2UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00200000 */ +#define GPIO_AFRL_AFSEL5_2 (0x4UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00400000 */ +#define GPIO_AFRL_AFSEL5_3 (0x8UL << GPIO_AFRL_AFSEL5_Pos) /*!< 0x00800000 */ +#define GPIO_AFRL_AFSEL6_Pos (24U) +#define GPIO_AFRL_AFSEL6_Msk (0xFUL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x0F000000 */ +#define GPIO_AFRL_AFSEL6 GPIO_AFRL_AFSEL6_Msk +#define GPIO_AFRL_AFSEL6_0 (0x1UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x01000000 */ +#define GPIO_AFRL_AFSEL6_1 (0x2UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x02000000 */ +#define GPIO_AFRL_AFSEL6_2 (0x4UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x04000000 */ +#define GPIO_AFRL_AFSEL6_3 (0x8UL << GPIO_AFRL_AFSEL6_Pos) /*!< 0x08000000 */ +#define GPIO_AFRL_AFSEL7_Pos (28U) +#define GPIO_AFRL_AFSEL7_Msk (0xFUL << GPIO_AFRL_AFSEL7_Pos) /*!< 0xF0000000 */ +#define GPIO_AFRL_AFSEL7 GPIO_AFRL_AFSEL7_Msk +#define GPIO_AFRL_AFSEL7_0 (0x1UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x10000000 */ +#define GPIO_AFRL_AFSEL7_1 (0x2UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x20000000 */ +#define GPIO_AFRL_AFSEL7_2 (0x4UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x40000000 */ +#define GPIO_AFRL_AFSEL7_3 (0x8UL << GPIO_AFRL_AFSEL7_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_AFRL_AFRL0 GPIO_AFRL_AFSEL0 +#define GPIO_AFRL_AFRL1 GPIO_AFRL_AFSEL1 +#define GPIO_AFRL_AFRL2 GPIO_AFRL_AFSEL2 +#define GPIO_AFRL_AFRL3 GPIO_AFRL_AFSEL3 +#define GPIO_AFRL_AFRL4 GPIO_AFRL_AFSEL4 +#define GPIO_AFRL_AFRL5 GPIO_AFRL_AFSEL5 +#define GPIO_AFRL_AFRL6 GPIO_AFRL_AFSEL6 +#define GPIO_AFRL_AFRL7 GPIO_AFRL_AFSEL7 + +/****************** Bit definition for GPIO_AFRH register *********************/ +#define GPIO_AFRH_AFSEL8_Pos (0U) +#define GPIO_AFRH_AFSEL8_Msk (0xFUL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x0000000F */ +#define GPIO_AFRH_AFSEL8 GPIO_AFRH_AFSEL8_Msk +#define GPIO_AFRH_AFSEL8_0 (0x1UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000001 */ +#define GPIO_AFRH_AFSEL8_1 (0x2UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000002 */ +#define GPIO_AFRH_AFSEL8_2 (0x4UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000004 */ +#define GPIO_AFRH_AFSEL8_3 (0x8UL << GPIO_AFRH_AFSEL8_Pos) /*!< 0x00000008 */ +#define GPIO_AFRH_AFSEL9_Pos (4U) +#define GPIO_AFRH_AFSEL9_Msk (0xFUL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x000000F0 */ +#define GPIO_AFRH_AFSEL9 GPIO_AFRH_AFSEL9_Msk +#define GPIO_AFRH_AFSEL9_0 (0x1UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000010 */ +#define GPIO_AFRH_AFSEL9_1 (0x2UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000020 */ +#define GPIO_AFRH_AFSEL9_2 (0x4UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000040 */ +#define GPIO_AFRH_AFSEL9_3 (0x8UL << GPIO_AFRH_AFSEL9_Pos) /*!< 0x00000080 */ +#define GPIO_AFRH_AFSEL10_Pos (8U) +#define GPIO_AFRH_AFSEL10_Msk (0xFUL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000F00 */ +#define GPIO_AFRH_AFSEL10 GPIO_AFRH_AFSEL10_Msk +#define GPIO_AFRH_AFSEL10_0 (0x1UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000100 */ +#define GPIO_AFRH_AFSEL10_1 (0x2UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000200 */ +#define GPIO_AFRH_AFSEL10_2 (0x4UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000400 */ +#define GPIO_AFRH_AFSEL10_3 (0x8UL << GPIO_AFRH_AFSEL10_Pos) /*!< 0x00000800 */ +#define GPIO_AFRH_AFSEL11_Pos (12U) +#define GPIO_AFRH_AFSEL11_Msk (0xFUL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x0000F000 */ +#define GPIO_AFRH_AFSEL11 GPIO_AFRH_AFSEL11_Msk +#define GPIO_AFRH_AFSEL11_0 (0x1UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00001000 */ +#define GPIO_AFRH_AFSEL11_1 (0x2UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00002000 */ +#define GPIO_AFRH_AFSEL11_2 (0x4UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00004000 */ +#define GPIO_AFRH_AFSEL11_3 (0x8UL << GPIO_AFRH_AFSEL11_Pos) /*!< 0x00008000 */ +#define GPIO_AFRH_AFSEL12_Pos (16U) +#define GPIO_AFRH_AFSEL12_Msk (0xFUL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x000F0000 */ +#define GPIO_AFRH_AFSEL12 GPIO_AFRH_AFSEL12_Msk +#define GPIO_AFRH_AFSEL12_0 (0x1UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00010000 */ +#define GPIO_AFRH_AFSEL12_1 (0x2UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00020000 */ +#define GPIO_AFRH_AFSEL12_2 (0x4UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00040000 */ +#define GPIO_AFRH_AFSEL12_3 (0x8UL << GPIO_AFRH_AFSEL12_Pos) /*!< 0x00080000 */ +#define GPIO_AFRH_AFSEL13_Pos (20U) +#define GPIO_AFRH_AFSEL13_Msk (0xFUL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00F00000 */ +#define GPIO_AFRH_AFSEL13 GPIO_AFRH_AFSEL13_Msk +#define GPIO_AFRH_AFSEL13_0 (0x1UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00100000 */ +#define GPIO_AFRH_AFSEL13_1 (0x2UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00200000 */ +#define GPIO_AFRH_AFSEL13_2 (0x4UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00400000 */ +#define GPIO_AFRH_AFSEL13_3 (0x8UL << GPIO_AFRH_AFSEL13_Pos) /*!< 0x00800000 */ +#define GPIO_AFRH_AFSEL14_Pos (24U) +#define GPIO_AFRH_AFSEL14_Msk (0xFUL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x0F000000 */ +#define GPIO_AFRH_AFSEL14 GPIO_AFRH_AFSEL14_Msk +#define GPIO_AFRH_AFSEL14_0 (0x1UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x01000000 */ +#define GPIO_AFRH_AFSEL14_1 (0x2UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x02000000 */ +#define GPIO_AFRH_AFSEL14_2 (0x4UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x04000000 */ +#define GPIO_AFRH_AFSEL14_3 (0x8UL << GPIO_AFRH_AFSEL14_Pos) /*!< 0x08000000 */ +#define GPIO_AFRH_AFSEL15_Pos (28U) +#define GPIO_AFRH_AFSEL15_Msk (0xFUL << GPIO_AFRH_AFSEL15_Pos) /*!< 0xF0000000 */ +#define GPIO_AFRH_AFSEL15 GPIO_AFRH_AFSEL15_Msk +#define GPIO_AFRH_AFSEL15_0 (0x1UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x10000000 */ +#define GPIO_AFRH_AFSEL15_1 (0x2UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x20000000 */ +#define GPIO_AFRH_AFSEL15_2 (0x4UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x40000000 */ +#define GPIO_AFRH_AFSEL15_3 (0x8UL << GPIO_AFRH_AFSEL15_Pos) /*!< 0x80000000 */ + +/* Legacy defines */ +#define GPIO_AFRH_AFRH0 GPIO_AFRH_AFSEL8 +#define GPIO_AFRH_AFRH1 GPIO_AFRH_AFSEL9 +#define GPIO_AFRH_AFRH2 GPIO_AFRH_AFSEL10 +#define GPIO_AFRH_AFRH3 GPIO_AFRH_AFSEL11 +#define GPIO_AFRH_AFRH4 GPIO_AFRH_AFSEL12 +#define GPIO_AFRH_AFRH5 GPIO_AFRH_AFSEL13 +#define GPIO_AFRH_AFRH6 GPIO_AFRH_AFSEL14 +#define GPIO_AFRH_AFRH7 GPIO_AFRH_AFSEL15 + +/****************** Bits definition for GPIO_BRR register ******************/ +#define GPIO_BRR_BR0_Pos (0U) +#define GPIO_BRR_BR0_Msk (0x1UL << GPIO_BRR_BR0_Pos) /*!< 0x00000001 */ +#define GPIO_BRR_BR0 GPIO_BRR_BR0_Msk +#define GPIO_BRR_BR1_Pos (1U) +#define GPIO_BRR_BR1_Msk (0x1UL << GPIO_BRR_BR1_Pos) /*!< 0x00000002 */ +#define GPIO_BRR_BR1 GPIO_BRR_BR1_Msk +#define GPIO_BRR_BR2_Pos (2U) +#define GPIO_BRR_BR2_Msk (0x1UL << GPIO_BRR_BR2_Pos) /*!< 0x00000004 */ +#define GPIO_BRR_BR2 GPIO_BRR_BR2_Msk +#define GPIO_BRR_BR3_Pos (3U) +#define GPIO_BRR_BR3_Msk (0x1UL << GPIO_BRR_BR3_Pos) /*!< 0x00000008 */ +#define GPIO_BRR_BR3 GPIO_BRR_BR3_Msk +#define GPIO_BRR_BR4_Pos (4U) +#define GPIO_BRR_BR4_Msk (0x1UL << GPIO_BRR_BR4_Pos) /*!< 0x00000010 */ +#define GPIO_BRR_BR4 GPIO_BRR_BR4_Msk +#define GPIO_BRR_BR5_Pos (5U) +#define GPIO_BRR_BR5_Msk (0x1UL << GPIO_BRR_BR5_Pos) /*!< 0x00000020 */ +#define GPIO_BRR_BR5 GPIO_BRR_BR5_Msk +#define GPIO_BRR_BR6_Pos (6U) +#define GPIO_BRR_BR6_Msk (0x1UL << GPIO_BRR_BR6_Pos) /*!< 0x00000040 */ +#define GPIO_BRR_BR6 GPIO_BRR_BR6_Msk +#define GPIO_BRR_BR7_Pos (7U) +#define GPIO_BRR_BR7_Msk (0x1UL << GPIO_BRR_BR7_Pos) /*!< 0x00000080 */ +#define GPIO_BRR_BR7 GPIO_BRR_BR7_Msk +#define GPIO_BRR_BR8_Pos (8U) +#define GPIO_BRR_BR8_Msk (0x1UL << GPIO_BRR_BR8_Pos) /*!< 0x00000100 */ +#define GPIO_BRR_BR8 GPIO_BRR_BR8_Msk +#define GPIO_BRR_BR9_Pos (9U) +#define GPIO_BRR_BR9_Msk (0x1UL << GPIO_BRR_BR9_Pos) /*!< 0x00000200 */ +#define GPIO_BRR_BR9 GPIO_BRR_BR9_Msk +#define GPIO_BRR_BR10_Pos (10U) +#define GPIO_BRR_BR10_Msk (0x1UL << GPIO_BRR_BR10_Pos) /*!< 0x00000400 */ +#define GPIO_BRR_BR10 GPIO_BRR_BR10_Msk +#define GPIO_BRR_BR11_Pos (11U) +#define GPIO_BRR_BR11_Msk (0x1UL << GPIO_BRR_BR11_Pos) /*!< 0x00000800 */ +#define GPIO_BRR_BR11 GPIO_BRR_BR11_Msk +#define GPIO_BRR_BR12_Pos (12U) +#define GPIO_BRR_BR12_Msk (0x1UL << GPIO_BRR_BR12_Pos) /*!< 0x00001000 */ +#define GPIO_BRR_BR12 GPIO_BRR_BR12_Msk +#define GPIO_BRR_BR13_Pos (13U) +#define GPIO_BRR_BR13_Msk (0x1UL << GPIO_BRR_BR13_Pos) /*!< 0x00002000 */ +#define GPIO_BRR_BR13 GPIO_BRR_BR13_Msk +#define GPIO_BRR_BR14_Pos (14U) +#define GPIO_BRR_BR14_Msk (0x1UL << GPIO_BRR_BR14_Pos) /*!< 0x00004000 */ +#define GPIO_BRR_BR14 GPIO_BRR_BR14_Msk +#define GPIO_BRR_BR15_Pos (15U) +#define GPIO_BRR_BR15_Msk (0x1UL << GPIO_BRR_BR15_Pos) /*!< 0x00008000 */ +#define GPIO_BRR_BR15 GPIO_BRR_BR15_Msk + +/* Legacy defines */ +#define GPIO_BRR_BR_0 GPIO_BRR_BR0 +#define GPIO_BRR_BR_1 GPIO_BRR_BR1 +#define GPIO_BRR_BR_2 GPIO_BRR_BR2 +#define GPIO_BRR_BR_3 GPIO_BRR_BR3 +#define GPIO_BRR_BR_4 GPIO_BRR_BR4 +#define GPIO_BRR_BR_5 GPIO_BRR_BR5 +#define GPIO_BRR_BR_6 GPIO_BRR_BR6 +#define GPIO_BRR_BR_7 GPIO_BRR_BR7 +#define GPIO_BRR_BR_8 GPIO_BRR_BR8 +#define GPIO_BRR_BR_9 GPIO_BRR_BR9 +#define GPIO_BRR_BR_10 GPIO_BRR_BR10 +#define GPIO_BRR_BR_11 GPIO_BRR_BR11 +#define GPIO_BRR_BR_12 GPIO_BRR_BR12 +#define GPIO_BRR_BR_13 GPIO_BRR_BR13 +#define GPIO_BRR_BR_14 GPIO_BRR_BR14 +#define GPIO_BRR_BR_15 GPIO_BRR_BR15 + + + +/******************************************************************************/ +/* */ +/* Inter-integrated Circuit Interface (I2C) */ +/* */ +/******************************************************************************/ +/******************* Bit definition for I2C_CR1 register *******************/ +#define I2C_CR1_PE_Pos (0U) +#define I2C_CR1_PE_Msk (0x1UL << I2C_CR1_PE_Pos) /*!< 0x00000001 */ +#define I2C_CR1_PE I2C_CR1_PE_Msk /*!< Peripheral enable */ +#define I2C_CR1_TXIE_Pos (1U) +#define I2C_CR1_TXIE_Msk (0x1UL << I2C_CR1_TXIE_Pos) /*!< 0x00000002 */ +#define I2C_CR1_TXIE I2C_CR1_TXIE_Msk /*!< TX interrupt enable */ +#define I2C_CR1_RXIE_Pos (2U) +#define I2C_CR1_RXIE_Msk (0x1UL << I2C_CR1_RXIE_Pos) /*!< 0x00000004 */ +#define I2C_CR1_RXIE I2C_CR1_RXIE_Msk /*!< RX interrupt enable */ +#define I2C_CR1_ADDRIE_Pos (3U) +#define I2C_CR1_ADDRIE_Msk (0x1UL << I2C_CR1_ADDRIE_Pos) /*!< 0x00000008 */ +#define I2C_CR1_ADDRIE I2C_CR1_ADDRIE_Msk /*!< Address match interrupt enable */ +#define I2C_CR1_NACKIE_Pos (4U) +#define I2C_CR1_NACKIE_Msk (0x1UL << I2C_CR1_NACKIE_Pos) /*!< 0x00000010 */ +#define I2C_CR1_NACKIE I2C_CR1_NACKIE_Msk /*!< NACK received interrupt enable */ +#define I2C_CR1_STOPIE_Pos (5U) +#define I2C_CR1_STOPIE_Msk (0x1UL << I2C_CR1_STOPIE_Pos) /*!< 0x00000020 */ +#define I2C_CR1_STOPIE I2C_CR1_STOPIE_Msk /*!< STOP detection interrupt enable */ +#define I2C_CR1_TCIE_Pos (6U) +#define I2C_CR1_TCIE_Msk (0x1UL << I2C_CR1_TCIE_Pos) /*!< 0x00000040 */ +#define I2C_CR1_TCIE I2C_CR1_TCIE_Msk /*!< Transfer complete interrupt enable */ +#define I2C_CR1_ERRIE_Pos (7U) +#define I2C_CR1_ERRIE_Msk (0x1UL << I2C_CR1_ERRIE_Pos) /*!< 0x00000080 */ +#define I2C_CR1_ERRIE I2C_CR1_ERRIE_Msk /*!< Errors interrupt enable */ +#define I2C_CR1_DNF_Pos (8U) +#define I2C_CR1_DNF_Msk (0xFUL << I2C_CR1_DNF_Pos) /*!< 0x00000F00 */ +#define I2C_CR1_DNF I2C_CR1_DNF_Msk /*!< Digital noise filter */ +#define I2C_CR1_ANFOFF_Pos (12U) +#define I2C_CR1_ANFOFF_Msk (0x1UL << I2C_CR1_ANFOFF_Pos) /*!< 0x00001000 */ +#define I2C_CR1_ANFOFF I2C_CR1_ANFOFF_Msk /*!< Analog noise filter OFF */ +#define I2C_CR1_SWRST_Pos (13U) +#define I2C_CR1_SWRST_Msk (0x1UL << I2C_CR1_SWRST_Pos) /*!< 0x00002000 */ +#define I2C_CR1_SWRST I2C_CR1_SWRST_Msk /*!< Software reset */ +#define I2C_CR1_TXDMAEN_Pos (14U) +#define I2C_CR1_TXDMAEN_Msk (0x1UL << I2C_CR1_TXDMAEN_Pos) /*!< 0x00004000 */ +#define I2C_CR1_TXDMAEN I2C_CR1_TXDMAEN_Msk /*!< DMA transmission requests enable */ +#define I2C_CR1_RXDMAEN_Pos (15U) +#define I2C_CR1_RXDMAEN_Msk (0x1UL << I2C_CR1_RXDMAEN_Pos) /*!< 0x00008000 */ +#define I2C_CR1_RXDMAEN I2C_CR1_RXDMAEN_Msk /*!< DMA reception requests enable */ +#define I2C_CR1_SBC_Pos (16U) +#define I2C_CR1_SBC_Msk (0x1UL << I2C_CR1_SBC_Pos) /*!< 0x00010000 */ +#define I2C_CR1_SBC I2C_CR1_SBC_Msk /*!< Slave byte control */ +#define I2C_CR1_NOSTRETCH_Pos (17U) +#define I2C_CR1_NOSTRETCH_Msk (0x1UL << I2C_CR1_NOSTRETCH_Pos) /*!< 0x00020000 */ +#define I2C_CR1_NOSTRETCH I2C_CR1_NOSTRETCH_Msk /*!< Clock stretching disable */ +#define I2C_CR1_WUPEN_Pos (18U) +#define I2C_CR1_WUPEN_Msk (0x1UL << I2C_CR1_WUPEN_Pos) /*!< 0x00040000 */ +#define I2C_CR1_WUPEN I2C_CR1_WUPEN_Msk /*!< Wakeup from STOP enable */ +#define I2C_CR1_GCEN_Pos (19U) +#define I2C_CR1_GCEN_Msk (0x1UL << I2C_CR1_GCEN_Pos) /*!< 0x00080000 */ +#define I2C_CR1_GCEN I2C_CR1_GCEN_Msk /*!< General call enable */ +#define I2C_CR1_SMBHEN_Pos (20U) +#define I2C_CR1_SMBHEN_Msk (0x1UL << I2C_CR1_SMBHEN_Pos) /*!< 0x00100000 */ +#define I2C_CR1_SMBHEN I2C_CR1_SMBHEN_Msk /*!< SMBus host address enable */ +#define I2C_CR1_SMBDEN_Pos (21U) +#define I2C_CR1_SMBDEN_Msk (0x1UL << I2C_CR1_SMBDEN_Pos) /*!< 0x00200000 */ +#define I2C_CR1_SMBDEN I2C_CR1_SMBDEN_Msk /*!< SMBus device default address enable */ +#define I2C_CR1_ALERTEN_Pos (22U) +#define I2C_CR1_ALERTEN_Msk (0x1UL << I2C_CR1_ALERTEN_Pos) /*!< 0x00400000 */ +#define I2C_CR1_ALERTEN I2C_CR1_ALERTEN_Msk /*!< SMBus alert enable */ +#define I2C_CR1_PECEN_Pos (23U) +#define I2C_CR1_PECEN_Msk (0x1UL << I2C_CR1_PECEN_Pos) /*!< 0x00800000 */ +#define I2C_CR1_PECEN I2C_CR1_PECEN_Msk /*!< PEC enable */ + +/****************** Bit definition for I2C_CR2 register ********************/ +#define I2C_CR2_SADD_Pos (0U) +#define I2C_CR2_SADD_Msk (0x3FFUL << I2C_CR2_SADD_Pos) /*!< 0x000003FF */ +#define I2C_CR2_SADD I2C_CR2_SADD_Msk /*!< Slave address (master mode) */ +#define I2C_CR2_RD_WRN_Pos (10U) +#define I2C_CR2_RD_WRN_Msk (0x1UL << I2C_CR2_RD_WRN_Pos) /*!< 0x00000400 */ +#define I2C_CR2_RD_WRN I2C_CR2_RD_WRN_Msk /*!< Transfer direction (master mode) */ +#define I2C_CR2_ADD10_Pos (11U) +#define I2C_CR2_ADD10_Msk (0x1UL << I2C_CR2_ADD10_Pos) /*!< 0x00000800 */ +#define I2C_CR2_ADD10 I2C_CR2_ADD10_Msk /*!< 10-bit addressing mode (master mode) */ +#define I2C_CR2_HEAD10R_Pos (12U) +#define I2C_CR2_HEAD10R_Msk (0x1UL << I2C_CR2_HEAD10R_Pos) /*!< 0x00001000 */ +#define I2C_CR2_HEAD10R I2C_CR2_HEAD10R_Msk /*!< 10-bit address header only read direction (master mode) */ +#define I2C_CR2_START_Pos (13U) +#define I2C_CR2_START_Msk (0x1UL << I2C_CR2_START_Pos) /*!< 0x00002000 */ +#define I2C_CR2_START I2C_CR2_START_Msk /*!< START generation */ +#define I2C_CR2_STOP_Pos (14U) +#define I2C_CR2_STOP_Msk (0x1UL << I2C_CR2_STOP_Pos) /*!< 0x00004000 */ +#define I2C_CR2_STOP I2C_CR2_STOP_Msk /*!< STOP generation (master mode) */ +#define I2C_CR2_NACK_Pos (15U) +#define I2C_CR2_NACK_Msk (0x1UL << I2C_CR2_NACK_Pos) /*!< 0x00008000 */ +#define I2C_CR2_NACK I2C_CR2_NACK_Msk /*!< NACK generation (slave mode) */ +#define I2C_CR2_NBYTES_Pos (16U) +#define I2C_CR2_NBYTES_Msk (0xFFUL << I2C_CR2_NBYTES_Pos) /*!< 0x00FF0000 */ +#define I2C_CR2_NBYTES I2C_CR2_NBYTES_Msk /*!< Number of bytes */ +#define I2C_CR2_RELOAD_Pos (24U) +#define I2C_CR2_RELOAD_Msk (0x1UL << I2C_CR2_RELOAD_Pos) /*!< 0x01000000 */ +#define I2C_CR2_RELOAD I2C_CR2_RELOAD_Msk /*!< NBYTES reload mode */ +#define I2C_CR2_AUTOEND_Pos (25U) +#define I2C_CR2_AUTOEND_Msk (0x1UL << I2C_CR2_AUTOEND_Pos) /*!< 0x02000000 */ +#define I2C_CR2_AUTOEND I2C_CR2_AUTOEND_Msk /*!< Automatic end mode (master mode) */ +#define I2C_CR2_PECBYTE_Pos (26U) +#define I2C_CR2_PECBYTE_Msk (0x1UL << I2C_CR2_PECBYTE_Pos) /*!< 0x04000000 */ +#define I2C_CR2_PECBYTE I2C_CR2_PECBYTE_Msk /*!< Packet error checking byte */ + +/******************* Bit definition for I2C_OAR1 register ******************/ +#define I2C_OAR1_OA1_Pos (0U) +#define I2C_OAR1_OA1_Msk (0x3FFUL << I2C_OAR1_OA1_Pos) /*!< 0x000003FF */ +#define I2C_OAR1_OA1 I2C_OAR1_OA1_Msk /*!< Interface own address 1 */ +#define I2C_OAR1_OA1MODE_Pos (10U) +#define I2C_OAR1_OA1MODE_Msk (0x1UL << I2C_OAR1_OA1MODE_Pos) /*!< 0x00000400 */ +#define I2C_OAR1_OA1MODE I2C_OAR1_OA1MODE_Msk /*!< Own address 1 10-bit mode */ +#define I2C_OAR1_OA1EN_Pos (15U) +#define I2C_OAR1_OA1EN_Msk (0x1UL << I2C_OAR1_OA1EN_Pos) /*!< 0x00008000 */ +#define I2C_OAR1_OA1EN I2C_OAR1_OA1EN_Msk /*!< Own address 1 enable */ + +/******************* Bit definition for I2C_OAR2 register ******************/ +#define I2C_OAR2_OA2_Pos (1U) +#define I2C_OAR2_OA2_Msk (0x7FUL << I2C_OAR2_OA2_Pos) /*!< 0x000000FE */ +#define I2C_OAR2_OA2 I2C_OAR2_OA2_Msk /*!< Interface own address 2 */ +#define I2C_OAR2_OA2MSK_Pos (8U) +#define I2C_OAR2_OA2MSK_Msk (0x7UL << I2C_OAR2_OA2MSK_Pos) /*!< 0x00000700 */ +#define I2C_OAR2_OA2MSK I2C_OAR2_OA2MSK_Msk /*!< Own address 2 masks */ +#define I2C_OAR2_OA2NOMASK (0x00000000UL) /*!< No mask */ +#define I2C_OAR2_OA2MASK01_Pos (8U) +#define I2C_OAR2_OA2MASK01_Msk (0x1UL << I2C_OAR2_OA2MASK01_Pos) /*!< 0x00000100 */ +#define I2C_OAR2_OA2MASK01 I2C_OAR2_OA2MASK01_Msk /*!< OA2[1] is masked, Only OA2[7:2] are compared */ +#define I2C_OAR2_OA2MASK02_Pos (9U) +#define I2C_OAR2_OA2MASK02_Msk (0x1UL << I2C_OAR2_OA2MASK02_Pos) /*!< 0x00000200 */ +#define I2C_OAR2_OA2MASK02 I2C_OAR2_OA2MASK02_Msk /*!< OA2[2:1] is masked, Only OA2[7:3] are compared */ +#define I2C_OAR2_OA2MASK03_Pos (8U) +#define I2C_OAR2_OA2MASK03_Msk (0x3UL << I2C_OAR2_OA2MASK03_Pos) /*!< 0x00000300 */ +#define I2C_OAR2_OA2MASK03 I2C_OAR2_OA2MASK03_Msk /*!< OA2[3:1] is masked, Only OA2[7:4] are compared */ +#define I2C_OAR2_OA2MASK04_Pos (10U) +#define I2C_OAR2_OA2MASK04_Msk (0x1UL << I2C_OAR2_OA2MASK04_Pos) /*!< 0x00000400 */ +#define I2C_OAR2_OA2MASK04 I2C_OAR2_OA2MASK04_Msk /*!< OA2[4:1] is masked, Only OA2[7:5] are compared */ +#define I2C_OAR2_OA2MASK05_Pos (8U) +#define I2C_OAR2_OA2MASK05_Msk (0x5UL << I2C_OAR2_OA2MASK05_Pos) /*!< 0x00000500 */ +#define I2C_OAR2_OA2MASK05 I2C_OAR2_OA2MASK05_Msk /*!< OA2[5:1] is masked, Only OA2[7:6] are compared */ +#define I2C_OAR2_OA2MASK06_Pos (9U) +#define I2C_OAR2_OA2MASK06_Msk (0x3UL << I2C_OAR2_OA2MASK06_Pos) /*!< 0x00000600 */ +#define I2C_OAR2_OA2MASK06 I2C_OAR2_OA2MASK06_Msk /*!< OA2[6:1] is masked, Only OA2[7] are compared */ +#define I2C_OAR2_OA2MASK07_Pos (8U) +#define I2C_OAR2_OA2MASK07_Msk (0x7UL << I2C_OAR2_OA2MASK07_Pos) /*!< 0x00000700 */ +#define I2C_OAR2_OA2MASK07 I2C_OAR2_OA2MASK07_Msk /*!< OA2[7:1] is masked, No comparison is done */ +#define I2C_OAR2_OA2EN_Pos (15U) +#define I2C_OAR2_OA2EN_Msk (0x1UL << I2C_OAR2_OA2EN_Pos) /*!< 0x00008000 */ +#define I2C_OAR2_OA2EN I2C_OAR2_OA2EN_Msk /*!< Own address 2 enable */ + +/******************* Bit definition for I2C_TIMINGR register *******************/ +#define I2C_TIMINGR_SCLL_Pos (0U) +#define I2C_TIMINGR_SCLL_Msk (0xFFUL << I2C_TIMINGR_SCLL_Pos) /*!< 0x000000FF */ +#define I2C_TIMINGR_SCLL I2C_TIMINGR_SCLL_Msk /*!< SCL low period (master mode) */ +#define I2C_TIMINGR_SCLH_Pos (8U) +#define I2C_TIMINGR_SCLH_Msk (0xFFUL << I2C_TIMINGR_SCLH_Pos) /*!< 0x0000FF00 */ +#define I2C_TIMINGR_SCLH I2C_TIMINGR_SCLH_Msk /*!< SCL high period (master mode) */ +#define I2C_TIMINGR_SDADEL_Pos (16U) +#define I2C_TIMINGR_SDADEL_Msk (0xFUL << I2C_TIMINGR_SDADEL_Pos) /*!< 0x000F0000 */ +#define I2C_TIMINGR_SDADEL I2C_TIMINGR_SDADEL_Msk /*!< Data hold time */ +#define I2C_TIMINGR_SCLDEL_Pos (20U) +#define I2C_TIMINGR_SCLDEL_Msk (0xFUL << I2C_TIMINGR_SCLDEL_Pos) /*!< 0x00F00000 */ +#define I2C_TIMINGR_SCLDEL I2C_TIMINGR_SCLDEL_Msk /*!< Data setup time */ +#define I2C_TIMINGR_PRESC_Pos (28U) +#define I2C_TIMINGR_PRESC_Msk (0xFUL << I2C_TIMINGR_PRESC_Pos) /*!< 0xF0000000 */ +#define I2C_TIMINGR_PRESC I2C_TIMINGR_PRESC_Msk /*!< Timings prescaler */ + +/******************* Bit definition for I2C_TIMEOUTR register *******************/ +#define I2C_TIMEOUTR_TIMEOUTA_Pos (0U) +#define I2C_TIMEOUTR_TIMEOUTA_Msk (0xFFFUL << I2C_TIMEOUTR_TIMEOUTA_Pos) /*!< 0x00000FFF */ +#define I2C_TIMEOUTR_TIMEOUTA I2C_TIMEOUTR_TIMEOUTA_Msk /*!< Bus timeout A */ +#define I2C_TIMEOUTR_TIDLE_Pos (12U) +#define I2C_TIMEOUTR_TIDLE_Msk (0x1UL << I2C_TIMEOUTR_TIDLE_Pos) /*!< 0x00001000 */ +#define I2C_TIMEOUTR_TIDLE I2C_TIMEOUTR_TIDLE_Msk /*!< Idle clock timeout detection */ +#define I2C_TIMEOUTR_TIMOUTEN_Pos (15U) +#define I2C_TIMEOUTR_TIMOUTEN_Msk (0x1UL << I2C_TIMEOUTR_TIMOUTEN_Pos) /*!< 0x00008000 */ +#define I2C_TIMEOUTR_TIMOUTEN I2C_TIMEOUTR_TIMOUTEN_Msk /*!< Clock timeout enable */ +#define I2C_TIMEOUTR_TIMEOUTB_Pos (16U) +#define I2C_TIMEOUTR_TIMEOUTB_Msk (0xFFFUL << I2C_TIMEOUTR_TIMEOUTB_Pos) /*!< 0x0FFF0000 */ +#define I2C_TIMEOUTR_TIMEOUTB I2C_TIMEOUTR_TIMEOUTB_Msk /*!< Bus timeout B */ +#define I2C_TIMEOUTR_TEXTEN_Pos (31U) +#define I2C_TIMEOUTR_TEXTEN_Msk (0x1UL << I2C_TIMEOUTR_TEXTEN_Pos) /*!< 0x80000000 */ +#define I2C_TIMEOUTR_TEXTEN I2C_TIMEOUTR_TEXTEN_Msk /*!< Extended clock timeout enable */ + +/****************** Bit definition for I2C_ISR register *********************/ +#define I2C_ISR_TXE_Pos (0U) +#define I2C_ISR_TXE_Msk (0x1UL << I2C_ISR_TXE_Pos) /*!< 0x00000001 */ +#define I2C_ISR_TXE I2C_ISR_TXE_Msk /*!< Transmit data register empty */ +#define I2C_ISR_TXIS_Pos (1U) +#define I2C_ISR_TXIS_Msk (0x1UL << I2C_ISR_TXIS_Pos) /*!< 0x00000002 */ +#define I2C_ISR_TXIS I2C_ISR_TXIS_Msk /*!< Transmit interrupt status */ +#define I2C_ISR_RXNE_Pos (2U) +#define I2C_ISR_RXNE_Msk (0x1UL << I2C_ISR_RXNE_Pos) /*!< 0x00000004 */ +#define I2C_ISR_RXNE I2C_ISR_RXNE_Msk /*!< Receive data register not empty */ +#define I2C_ISR_ADDR_Pos (3U) +#define I2C_ISR_ADDR_Msk (0x1UL << I2C_ISR_ADDR_Pos) /*!< 0x00000008 */ +#define I2C_ISR_ADDR I2C_ISR_ADDR_Msk /*!< Address matched (slave mode) */ +#define I2C_ISR_NACKF_Pos (4U) +#define I2C_ISR_NACKF_Msk (0x1UL << I2C_ISR_NACKF_Pos) /*!< 0x00000010 */ +#define I2C_ISR_NACKF I2C_ISR_NACKF_Msk /*!< NACK received flag */ +#define I2C_ISR_STOPF_Pos (5U) +#define I2C_ISR_STOPF_Msk (0x1UL << I2C_ISR_STOPF_Pos) /*!< 0x00000020 */ +#define I2C_ISR_STOPF I2C_ISR_STOPF_Msk /*!< STOP detection flag */ +#define I2C_ISR_TC_Pos (6U) +#define I2C_ISR_TC_Msk (0x1UL << I2C_ISR_TC_Pos) /*!< 0x00000040 */ +#define I2C_ISR_TC I2C_ISR_TC_Msk /*!< Transfer complete (master mode) */ +#define I2C_ISR_TCR_Pos (7U) +#define I2C_ISR_TCR_Msk (0x1UL << I2C_ISR_TCR_Pos) /*!< 0x00000080 */ +#define I2C_ISR_TCR I2C_ISR_TCR_Msk /*!< Transfer complete reload */ +#define I2C_ISR_BERR_Pos (8U) +#define I2C_ISR_BERR_Msk (0x1UL << I2C_ISR_BERR_Pos) /*!< 0x00000100 */ +#define I2C_ISR_BERR I2C_ISR_BERR_Msk /*!< Bus error */ +#define I2C_ISR_ARLO_Pos (9U) +#define I2C_ISR_ARLO_Msk (0x1UL << I2C_ISR_ARLO_Pos) /*!< 0x00000200 */ +#define I2C_ISR_ARLO I2C_ISR_ARLO_Msk /*!< Arbitration lost */ +#define I2C_ISR_OVR_Pos (10U) +#define I2C_ISR_OVR_Msk (0x1UL << I2C_ISR_OVR_Pos) /*!< 0x00000400 */ +#define I2C_ISR_OVR I2C_ISR_OVR_Msk /*!< Overrun/Underrun */ +#define I2C_ISR_PECERR_Pos (11U) +#define I2C_ISR_PECERR_Msk (0x1UL << I2C_ISR_PECERR_Pos) /*!< 0x00000800 */ +#define I2C_ISR_PECERR I2C_ISR_PECERR_Msk /*!< PEC error in reception */ +#define I2C_ISR_TIMEOUT_Pos (12U) +#define I2C_ISR_TIMEOUT_Msk (0x1UL << I2C_ISR_TIMEOUT_Pos) /*!< 0x00001000 */ +#define I2C_ISR_TIMEOUT I2C_ISR_TIMEOUT_Msk /*!< Timeout or Tlow detection flag */ +#define I2C_ISR_ALERT_Pos (13U) +#define I2C_ISR_ALERT_Msk (0x1UL << I2C_ISR_ALERT_Pos) /*!< 0x00002000 */ +#define I2C_ISR_ALERT I2C_ISR_ALERT_Msk /*!< SMBus alert */ +#define I2C_ISR_BUSY_Pos (15U) +#define I2C_ISR_BUSY_Msk (0x1UL << I2C_ISR_BUSY_Pos) /*!< 0x00008000 */ +#define I2C_ISR_BUSY I2C_ISR_BUSY_Msk /*!< Bus busy */ +#define I2C_ISR_DIR_Pos (16U) +#define I2C_ISR_DIR_Msk (0x1UL << I2C_ISR_DIR_Pos) /*!< 0x00010000 */ +#define I2C_ISR_DIR I2C_ISR_DIR_Msk /*!< Transfer direction (slave mode) */ +#define I2C_ISR_ADDCODE_Pos (17U) +#define I2C_ISR_ADDCODE_Msk (0x7FUL << I2C_ISR_ADDCODE_Pos) /*!< 0x00FE0000 */ +#define I2C_ISR_ADDCODE I2C_ISR_ADDCODE_Msk /*!< Address match code (slave mode) */ + +/****************** Bit definition for I2C_ICR register *********************/ +#define I2C_ICR_ADDRCF_Pos (3U) +#define I2C_ICR_ADDRCF_Msk (0x1UL << I2C_ICR_ADDRCF_Pos) /*!< 0x00000008 */ +#define I2C_ICR_ADDRCF I2C_ICR_ADDRCF_Msk /*!< Address matched clear flag */ +#define I2C_ICR_NACKCF_Pos (4U) +#define I2C_ICR_NACKCF_Msk (0x1UL << I2C_ICR_NACKCF_Pos) /*!< 0x00000010 */ +#define I2C_ICR_NACKCF I2C_ICR_NACKCF_Msk /*!< NACK clear flag */ +#define I2C_ICR_STOPCF_Pos (5U) +#define I2C_ICR_STOPCF_Msk (0x1UL << I2C_ICR_STOPCF_Pos) /*!< 0x00000020 */ +#define I2C_ICR_STOPCF I2C_ICR_STOPCF_Msk /*!< STOP detection clear flag */ +#define I2C_ICR_BERRCF_Pos (8U) +#define I2C_ICR_BERRCF_Msk (0x1UL << I2C_ICR_BERRCF_Pos) /*!< 0x00000100 */ +#define I2C_ICR_BERRCF I2C_ICR_BERRCF_Msk /*!< Bus error clear flag */ +#define I2C_ICR_ARLOCF_Pos (9U) +#define I2C_ICR_ARLOCF_Msk (0x1UL << I2C_ICR_ARLOCF_Pos) /*!< 0x00000200 */ +#define I2C_ICR_ARLOCF I2C_ICR_ARLOCF_Msk /*!< Arbitration lost clear flag */ +#define I2C_ICR_OVRCF_Pos (10U) +#define I2C_ICR_OVRCF_Msk (0x1UL << I2C_ICR_OVRCF_Pos) /*!< 0x00000400 */ +#define I2C_ICR_OVRCF I2C_ICR_OVRCF_Msk /*!< Overrun/Underrun clear flag */ +#define I2C_ICR_PECCF_Pos (11U) +#define I2C_ICR_PECCF_Msk (0x1UL << I2C_ICR_PECCF_Pos) /*!< 0x00000800 */ +#define I2C_ICR_PECCF I2C_ICR_PECCF_Msk /*!< PAC error clear flag */ +#define I2C_ICR_TIMOUTCF_Pos (12U) +#define I2C_ICR_TIMOUTCF_Msk (0x1UL << I2C_ICR_TIMOUTCF_Pos) /*!< 0x00001000 */ +#define I2C_ICR_TIMOUTCF I2C_ICR_TIMOUTCF_Msk /*!< Timeout clear flag */ +#define I2C_ICR_ALERTCF_Pos (13U) +#define I2C_ICR_ALERTCF_Msk (0x1UL << I2C_ICR_ALERTCF_Pos) /*!< 0x00002000 */ +#define I2C_ICR_ALERTCF I2C_ICR_ALERTCF_Msk /*!< Alert clear flag */ + +/****************** Bit definition for I2C_PECR register *********************/ +#define I2C_PECR_PEC_Pos (0U) +#define I2C_PECR_PEC_Msk (0xFFUL << I2C_PECR_PEC_Pos) /*!< 0x000000FF */ +#define I2C_PECR_PEC I2C_PECR_PEC_Msk /*!< PEC register */ + +/****************** Bit definition for I2C_RXDR register *********************/ +#define I2C_RXDR_RXDATA_Pos (0U) +#define I2C_RXDR_RXDATA_Msk (0xFFUL << I2C_RXDR_RXDATA_Pos) /*!< 0x000000FF */ +#define I2C_RXDR_RXDATA I2C_RXDR_RXDATA_Msk /*!< 8-bit receive data */ + +/****************** Bit definition for I2C_TXDR register *********************/ +#define I2C_TXDR_TXDATA_Pos (0U) +#define I2C_TXDR_TXDATA_Msk (0xFFUL << I2C_TXDR_TXDATA_Pos) /*!< 0x000000FF */ +#define I2C_TXDR_TXDATA I2C_TXDR_TXDATA_Msk /*!< 8-bit transmit data */ + +/******************************************************************************/ +/* */ +/* Independent WATCHDOG */ +/* */ +/******************************************************************************/ +/******************* Bit definition for IWDG_KR register ********************/ +#define IWDG_KR_KEY_Pos (0U) +#define IWDG_KR_KEY_Msk (0xFFFFUL << IWDG_KR_KEY_Pos) /*!< 0x0000FFFF */ +#define IWDG_KR_KEY IWDG_KR_KEY_Msk /*! + MikroElektronika +

+ +--- + +# `DATE` + +## Changes + +- [`DATE`](#date) + - [Changes](#changes) + - [NEW HARDWARE](#new-hardware) + +### NEW HARDWARE + +Support added for following hardware: + +- STM32L422RB_TB MCU Support package for GCC & Clang + - STM32L422RB + - STM32L422TB + +--- diff --git a/resources/queries/mcus/STM32L422RB/Devices.json b/resources/queries/mcus/STM32L422RB/Devices.json new file mode 100644 index 000000000..5e3699c71 --- /dev/null +++ b/resources/queries/mcus/STM32L422RB/Devices.json @@ -0,0 +1,18 @@ +{ + "def_file":"STM32L422RB.json", + "family_uid":"STM32", + "flash":"128", + "icon":"images/mcu/stm32.png", + "max_speed":"80.000", + "name":"STM32L422RB", + "ram":"40960", + "sdk_config":"{\"MCU_NAME\":\"STM32L422RB\",\"CORE_NAME\":\"M4\",\"_MSDK_HAL_LOW_LEVEL_TARGET_\":\"mikroe\",\"_MSDK_ETH_PHY_CHIP_\":\"NULL\"}", + "necto_config":"", + "uid":"STM32L422RB", + "vendor":"STMicroelectronics", + "compiler_flags":"", + "linker_flags":"", + "tft_socket":"1", + "sdk_support":"0", + "installer_package":"{\"clang-llvm\": \"arm_gcc_clang_stm32l422rb_tb\", \"gcc_arm_none_eabi\": \"arm_gcc_clang_stm32l422rb_tb\"}" +} \ No newline at end of file diff --git a/resources/queries/mcus/STM32L422RB/LinkerTables.json b/resources/queries/mcus/STM32L422RB/LinkerTables.json new file mode 100644 index 000000000..6bee0c878 --- /dev/null +++ b/resources/queries/mcus/STM32L422RB/LinkerTables.json @@ -0,0 +1,36 @@ +{ + "device_uid": "STM32L422RB", + "tables": [ + { + "BoardToDevice": { + "board_uid": ["GENERIC_ARM_BOARD"] + } + }, + { + "CompilerToDevice": { + "compiler_uid": [ + "clang-llvm", + "gcc_arm_none_eabi" + ] + } + }, + { + "DeviceToPackage": { + "package_uid": [ + "64/UFBGA", + "64/LQFP" + ] + } + }, + { + "DeviceToSocket": { + "socket_uid": ["NONE"] + } + }, + { + "SDKToDevice": { + "sdk_uid": "2.11.3+" + } + } + ] +} \ No newline at end of file diff --git a/resources/queries/mcus/STM32L422TB/Devices.json b/resources/queries/mcus/STM32L422TB/Devices.json new file mode 100644 index 000000000..f503350d1 --- /dev/null +++ b/resources/queries/mcus/STM32L422TB/Devices.json @@ -0,0 +1,18 @@ +{ + "def_file":"STM32L422TB.json", + "family_uid":"STM32", + "flash":"128", + "icon":"images/mcu/stm32.png", + "max_speed":"80.000", + "name":"STM32L422TB", + "ram":"40960", + "sdk_config":"{\"MCU_NAME\":\"STM32L422TB\",\"CORE_NAME\":\"M4\",\"_MSDK_HAL_LOW_LEVEL_TARGET_\":\"mikroe\",\"_MSDK_ETH_PHY_CHIP_\":\"NULL\"}", + "necto_config":"", + "uid":"STM32L422TB", + "vendor":"STMicroelectronics", + "compiler_flags":"", + "linker_flags":"", + "tft_socket":"1", + "sdk_support":"0", + "installer_package":"{\"clang-llvm\": \"arm_gcc_clang_stm32l422rb_tb\", \"gcc_arm_none_eabi\": \"arm_gcc_clang_stm32l422rb_tb\"}" +} \ No newline at end of file diff --git a/resources/queries/mcus/STM32L422TB/LinkerTables.json b/resources/queries/mcus/STM32L422TB/LinkerTables.json new file mode 100644 index 000000000..f96cee97a --- /dev/null +++ b/resources/queries/mcus/STM32L422TB/LinkerTables.json @@ -0,0 +1,35 @@ +{ + "device_uid": "STM32L422TB", + "tables": [ + { + "BoardToDevice": { + "board_uid": ["GENERIC_ARM_BOARD"] + } + }, + { + "CompilerToDevice": { + "compiler_uid": [ + "clang-llvm", + "gcc_arm_none_eabi" + ] + } + }, + { + "DeviceToPackage": { + "package_uid": [ + "36/WLCSP" + ] + } + }, + { + "DeviceToSocket": { + "socket_uid": ["NONE"] + } + }, + { + "SDKToDevice": { + "sdk_uid": "2.11.3+" + } + } + ] +} \ No newline at end of file From 7a29c253468b5854200bd2c43c58c79a8d985fa5 Mon Sep 17 00:00:00 2001 From: github-actions Date: Thu, 31 Oct 2024 07:02:26 +0000 Subject: [PATCH 4/8] Remove old changelog file after moving it --- changelog/new_hw.md | 23 ----------------------- 1 file changed, 23 deletions(-) delete mode 100644 changelog/new_hw.md diff --git a/changelog/new_hw.md b/changelog/new_hw.md deleted file mode 100644 index cbeb4b3d8..000000000 --- a/changelog/new_hw.md +++ /dev/null @@ -1,23 +0,0 @@ -

- MikroElektronika -

- ---- - -# `DATE` - -## Changes - -- [`DATE`](#date) - - [Changes](#changes) - - [NEW HARDWARE](#new-hardware) - -### NEW HARDWARE - -Support added for following hardware: - -- STM32L422RB_TB MCU Support package for GCC & Clang - - STM32L422RB - - STM32L422TB - ---- From 78b72b292df94c7a462c84a1b0af91be399927a3 Mon Sep 17 00:00:00 2001 From: github-actions Date: Thu, 31 Oct 2024 07:02:27 +0000 Subject: [PATCH 5/8] Updated changelog files with latest release info. --- changelog/2024-10-31.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 changelog/2024-10-31.md diff --git a/changelog/2024-10-31.md b/changelog/2024-10-31.md new file mode 100644 index 000000000..1f3b94246 --- /dev/null +++ b/changelog/2024-10-31.md @@ -0,0 +1,23 @@ +

+ MikroElektronika +

+ +--- + +# 2024-10-31 + +## Changes + +- [2024-10-31](#2024-10-31) + - [Changes](#changes) + - [NEW HARDWARE](#new-hardware) + +### NEW HARDWARE + +Support added for following hardware: + +- STM32L422RB_TB MCU Support package for GCC & Clang + - STM32L422RB + - STM32L422TB + +--- From 47a22001b907fdcc27fdb03a95cd6a37c73a6fef Mon Sep 17 00:00:00 2001 From: github-actions Date: Thu, 31 Oct 2024 07:31:13 +0000 Subject: [PATCH 6/8] Updated necto_db_dev.db with latest merged release. --- necto_db_dev.db | Bin 9411584 -> 9411584 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/necto_db_dev.db b/necto_db_dev.db index 2b4ca7ac0845993ba3fb6d4cf340aa06e9d7a8c8..9169cb86fb3261e8f6d54a4edd0f9bf4095d7856 100644 GIT binary patch delta 15689 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 delta 15708 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 U`t6KR=AK{YK>#y7(TFMhZ*;>Eo&W#< From 748c6f6e785be692250d85c59adda3b2d7e32716 Mon Sep 17 00:00:00 2001 From: github-actions Date: Thu, 31 Oct 2024 07:38:04 +0000 Subject: [PATCH 7/8] Updated necto_db.db with latest merged release. --- necto_db.db | Bin 9403392 -> 9409536 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/necto_db.db b/necto_db.db index cdd9045e48aa209e10f92b5b7fbc69e56fee366d..91b36a17ff6019dbe38859d7194869085ca5a3bc 100644 GIT binary patch delta 5824 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 T8S_~(wY)P-`uz&`tMq>WkA*w8 delta 4188 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 z Date: Thu, 31 Oct 2024 13:32:44 +0000 Subject: [PATCH 8/8] Updated necto_db_dev.db with latest merged release. --- necto_db_dev.db | Bin 9411584 -> 9720832 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/necto_db_dev.db b/necto_db_dev.db index 9169cb86fb3261e8f6d54a4edd0f9bf4095d7856..7d8d06edf544a9b1092bdf7efba7592e02250161 100644 GIT binary patch delta 258143 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 z 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 delta 19310 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